多线程之锁

​

 

/*
*作者：呆萌老师
*☑csdn认证讲师
*☑51cto高级讲师
*☑腾讯课堂认证讲师
*☑网易云课堂认证讲师
*☑华为开发者学堂认证讲师
*☑爱奇艺千人名师计划成员
*在这里给大家分享技术、知识和生活
*各种干货，记得关注哦！
*vx：it_daimeng
*/

　　

线程锁分两种:内置锁(synchronized)和显式锁(ReentrantLock)

简单对比:

主要相同点：Lock能完成synchronized所实现的所有功能
主要不同点：Lock有比synchronized更精确的线程语义和更好的性能，当许多线程都在争用同一个锁时，使用 ReentrantLock 的总体开支通常要比 synchronized 少得多。 
synchronized会自动释放锁，而Lock一定要求程序员手工释放，为了防止忘记释放锁，一般在finally从句中释放。

Synchronized不能设置等待时间，所以如果等待的资源一直被占用，可能会出现死锁.

ReentrantLock会灵活一点，可以设置等待的时间，如果等待的时间到了，就会去做其它的任务.

 

package com.wowowo.lock;

public class SellTicket implements Runnable {
    
    private static int tickets=100;
    
    
    public void run()
    {
         while(true)
         {
             
             /*
             //隐士锁 内置锁 方式1 锁住代码块
             synchronized (this) {                
            
                 if(tickets>0)
                 {                 
                     System.out.println(Thread.currentThread().getName()+"售出第..."+tickets+"...张票");
                     
                     tickets--;
                     
                     try {
                        Thread.sleep(10); //休眠 10毫秒
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                     
                 }
                
             }*/
            //方式 2
             sellTicket();   
         }
        
    }
    
    //方式2 锁住方法(成员方法或静态方法)
    public synchronized void sellTicket()
    {        
         if(tickets>0)
         {                 
             System.out.println(Thread.currentThread().getName()+"售出第..."+tickets+"...张票");
             
             tickets--;
             
             try {
                Thread.sleep(10); //休眠 10毫秒
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
             
         }
    }
 

}

　　

 

package com.wowowo.lock;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class SellTicket2 implements Runnable {

	private static int tickets=100;
	
	//显示锁
	private Lock lock=new ReentrantLock();
	
	
	@Override
	public void run() {
		// TODO Auto-generated method stub
		
		while(true)
		{
			lock.lock(); //上锁
			
			//lock.tryLock(arg0, arg1)//设置等待的时间的
			if(tickets>0)
			{
				System.out.println(Thread.currentThread().getName()+"售出第.."+tickets+"..张票");
				
				tickets--;
				
				try {
					Thread.sleep(10);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}				
			}			
			//开锁
			lock.unlock(); 
			
		}
		
	}
	
	

}

　　

package com.wowowo.lock;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Test {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		//创建线程池对象
		 ExecutorService pool= Executors.newFixedThreadPool(3);
		 
		 //创建售票任务 对象
		 SellTicket2 sellTicket=new SellTicket2();
		 
		 pool.submit(sellTicket);
		 
		 pool.submit(sellTicket);
		 
		 pool.submit(sellTicket);
		
		
	}

}

　　

 

​