1.线程同步问题的产生

1. package com.zejian.test;  
2. /**  
3.  * @author zejian  
4.  * @time 2016年3月12日 下午2:54:18  
5.  * @decrition 模拟卖票系统，该案例只考虑单方面卖票，其他情况暂时不考虑  
6.  */  
7. public class TicketDemo {  
8.       
9.     public static void main(String[] args)   
10.     {  
11.         Ticket t = new Ticket();//创建一个线程任务对象。  
12.           
13.         //创建4个线程同时卖票  
14.         Thread t1 = new Thread(t);  
15.         Thread t2 = new Thread(t);  
16.         Thread t3 = new Thread(t);  
17.         Thread t4 = new Thread(t);  
18.         //启动线程  
19.         t1.start();  
20.         t2.start();  
21.         t3.start();  
22.         t4.start();  
23.     }  
24. }  

从运行结果，我们就可以看出我们4个售票窗口同时卖出了1号票，这显然是不合逻辑的，其实这个问题就是我们前面所说的线程同步问题。不同的线程都对同一个数据进了操作这就容易导致数据错乱的问题，也就是线程不同步。那么这个问题该怎么解决呢？在给出解决思路之前我们先来分析一下这个问题是怎么产生的？我们声明一个线程类Ticket，在这个类中我们又声明了一个成员变量num也就是票的数量，然后我们通过run方法不断的去获取票数并输出，最后我们在外部类TicketDemo中创建了四个线程同时操作这个数据，运行后就出现我们刚才所说的线程同步问题，从这里我们可以看出产生线程同步(线程安全)问题的条件有两个：1.多个线程在操作共享的数据（num），2.操作共享数据的线程代码有多条（4条线程）；既然原因知道了，那该怎么解决？

 

在java中有两种机制可以防止线程安全的发生，Java语言提供了一个synchronized关键字来解决这问题，同时在Java SE5.0引入了Lock锁对象的相关类，接下来我们分别介绍这两种方法

在给出解决代码前我们先来介绍一个知识点：Lock，锁对象。在java中锁是用来控制多个线程访问共享资源的方式，一般来说，一个锁能够防止多个线程同时访问共享资源（但有的锁可以允许多个线程并发访问共享资源，比如读写锁，后面我们会分析）。在Lock接口出现之前，java程序是靠synchronized关键字（后面分析）实现锁功能的，而JAVA SE5.0之后并发包中新增了Lock接口用来实现锁的功能，它提供了与synchronized关键字类似的同步功能，只是在使用时需要显式地获取和释放锁，缺点就是缺少像synchronized那样隐式获取释放锁的便捷性，但是却拥有了锁获取与释放的可操作性，可中断的获取锁以及超时获取锁等多种synchronized关键字所不具备的同步特性。接下来我们就来介绍Lock接口的主要API方便我们学习

方法	相关描述内容
void lock()	获取锁，调用该方法当前线程会获取锁，当获取锁后。从该方法返回
void lockInterruptibly() throws InterruptedException	可中断获取锁和lock()方法不同的是该方法会响应中断，即在获取锁 中可以中断当前线程。例如某个线程在等待一个锁的控制权的这段时 间需要中断。
boolean tryLock()	尝试非阻塞获取锁，调用该方法后立即返回，如果能够获取锁则返回 true，否则返回false。
boolean tryLock(long time,TimeUnit unit) throws  InterruptedException	超时获取锁，当前线程在以下3种情况返回： 1.当前线程在超时时间内获取了锁 2.当前线程在超时时间被中断 3.当前线程超时时间结束，返回false
void unlock()	释放锁
Condition newCondition()	条件对象，获取等待通知组件。该组件和当前的锁绑定，当前线程只有 获取了锁，才能调用该组件的await()方法，而调用后，当前线程将缩放 锁。

这里先介绍一下API，后面我们将结合Lock接口的实现子类ReentrantLock使用某些方法。

重入锁，顾名思义就是支持重新进入的锁，它表示该锁能够支持一个线程对资源的重复加锁，也就是说在调用lock()方法时，已经获取到锁的线程，能够再次调用lock()方法获取锁而不被阻塞，同时还支持获取锁的公平性和非公平性。这里的公平是在绝对时间上，先对锁进行获取的请求一定先被满足，那么这个锁是公平锁，反之，是不公平的。那么该如何使用呢？看范例代码：

1. ReentrantLock lock = new ReentrantLock(); //参数默认false，不公平锁    
2. ReentrantLock lock = new ReentrantLock(true); //公平锁    
3.     
4. lock.lock(); //如果被其它资源锁定，会在此等待锁释放，达到暂停的效果    
5. try {    
6.     //操作    
7. } finally {    
8.     lock.unlock();  //释放锁  
9. }    

1. ReentrantLock lock = new ReentrantLock();    
2. if (lock.tryLock()) {  //如果已经被lock，则立即返回false不会等待，达到忽略操作的效果     
3.     try {    
4.         //操作    
5.     } finally {    
6.         lock.unlock();    
7.    }    
8. }    

1. ReentrantLock lock = new ReentrantLock(true); //公平锁    
2. try {    
3.     if (lock.tryLock(5, TimeUnit.SECONDS)) {        
4.         //如果已经被lock，尝试等待5s，看是否可以获得锁，如果5s后仍然无法获得锁则返回false继续执行    
5.        try {    
6.             //操作    
7.         } finally {    
8.             lock.unlock();    
9.         }    
10.     }    
11. } catch (InterruptedException e) {    
12.     e.printStackTrace(); //当前线程被中断时(interrupt)，会抛InterruptedException                     
13. }    

1. package com.zejian.test;  
2. import java.util.concurrent.locks.Lock;  
3. import java.util.concurrent.locks.ReentrantLock;  
4. /** 
5.  * @author zejian 
6.  * @time 2016年3月12日 下午2:55:42 
7.  * @decrition 模拟卖票线程 
8.  */  
9. public class Ticket implements Runnable  
10. {  
11.     //创建锁对象  
12.     private Lock ticketLock = new ReentrantLock();  
13.     //当前拥有的票数  
14.     private  int num = 100;  
15.     public void run()  
16.     {  
17.         while(true)  
18.         {         
19.                 ticketLock.lock();//获取锁  
20.                 if(num>0)  
21.                 {  
22.                   
23.                     try{  
24.                         Thread.sleep(10);  
25.                         //输出卖票信息  
26.                         System.out.println(Thread.currentThread().getName()+".....sale...."+num--);  
27.                     }catch (InterruptedException e){  
28.                         Thread.currentThread().interrupt();//出现异常就中断  
29.                     }finally{  
30.                         ticketLock.unlock();//释放锁  
31.                     }     
32.                 }  
33.         }  
34.     }  
35. }  

1. public synchronized void method{  
2.   //method body  
3. }  

1. private Lock ticketLock = new ReentrantLock();  
2. public void method{  
3.  ticketLock.lock();  
4.  try{  
5.   //.......  
6.  }finally{  
7.    ticketLock.unlock();  
8.  }  
9. }  

1. Object obj = new Object();  
2. synchronized(obj){  
3.   //需要同步的代码  
4. }  

嗯，同步代码块解决，运行结果也正常。到此同步问题也就解决了，当然代码同步也是要牺牲效率为前提的：

同步的好处：解决了线程的安全问题。

就这样我们创建了一个条件对象。注意这里返回的对象是与该锁（ticketLock）相关的条件对象。下面是条件对象的API：

1. package com.zejian.test;  
2. /** 
3.  * @author zejian 
4.  * @time 2016年3月12日 下午10:29:12 
5.  * @decrition 单生产者单消费者模式 
6.  */  
7. public class Single_Producer_Consumer {  
8.       
9.     public static void main(String[] args)   
10.     {  
11.         KaoYaResource r = new KaoYaResource();  
12.         Producer pro = new Producer(r);  
13.         Consumer con = new Consumer(r);  
14.         //生产者线程  
15.         Thread t0 = new Thread(pro);  
16.         //消费者线程  
17.         Thread t2 = new Thread(con);  
18.         //启动线程  
19.         t0.start();  
20.         t2.start();  
21.     }  
22. }  
23. /** 
24.  * @author zejian 
25.  * @time 2016年3月12日 下午11:02:22 
26.  * @decrition 生产者线程 
27.  */  
28. class Producer implements Runnable  
29. {  
30.     private KaoYaResource r;  
31.     Producer(KaoYaResource r)  
32.     {  
33.         this.r = r;  
34.     }  
35.     public void run()  
36.     {  
37.         while(true)  
38.         {  
39.             r.product("北京烤鸭");  
40.         }  
41.     }  
42. }  
43. /** 
44.  * @author zejian 
45.  * @time 2016年3月12日 下午11:02:05 
46.  * @decrition 消费者线程 
47.  */  
48. class Consumer implements Runnable  
49. {  
50.     private KaoYaResource r;  
51.     Consumer(KaoYaResource r)  
52.     {  
53.         this.r = r;  
54.     }  
55.     public void run()  
56.     {  
57.         while(true)  
58.         {  
59.             r.consume();  
60.         }  
61.     }  
62. }  

1. package com.zejian.test;  
2. import java.util.concurrent.locks.Condition;  
3. import java.util.concurrent.locks.Lock;  
4. import java.util.concurrent.locks.ReentrantLock;  
5. /** 
6.  * @author zejian 
7.  * @time 2016年3月13日 上午9:55:35 
8.  * @decrition 通过对象锁的方式来实现等待/通知机制 
9.  */  
10. public class KaoyaResourceByLock {  
11.       
12.     private String name;  
13.     private int count = 1;//烤鸭的初始数量  
14.     private boolean flag = false;//判断是否有需要线程等待的标志  
15.     //创建一个锁对象  
16.     private Lock resourceLock=new ReentrantLock();  
17.     //创建条件对象  
18.     private Condition condition= resourceLock.newCondition();  
19.     /** 
20.      * 生产烤鸭 
21.      */  
22.     public  void product(String name){  
23.         resourceLock.lock();//先获取锁  
24.         try{  
25.             if(flag){  
26.                 try {  
27.                     condition.await();  
28.                 } catch (InterruptedException e) {  
29.                     e.printStackTrace();  
30.                 }  
31.             }  
32.             this.name=name+count;//设置烤鸭的名称  
33.             count++;  
34.             System.out.println(Thread.currentThread().getName()+"...生产者..."+this.name);  
35.             flag=true;//有烤鸭后改变标志  
36.             condition.signalAll();//通知消费线程可以消费了  
37.         }finally{  
38.             resourceLock.unlock();  
39.         }     
40.     }  
41.       
42.     /** 
43.      * 消费烤鸭 
44.      */  
45.     public  void consume(){  
46.         resourceLock.lock();  
47.         try{  
48.         if(!flag){//如果没有烤鸭就等待  
49.             try{condition.await();}catch(InterruptedException e){}  
50.         }  
51.         System.out.println(Thread.currentThread().getName()+"...消费者........"+this.name);//消费烤鸭1  
52.         flag = false;  
53.         condition.signalAll();//通知生产者生产烤鸭  
54.         }finally{  
55.             resourceLock.unlock();  
56.         }  
57.     }  
58. }  

分析完了单生产者单消费者模式，我们再来聊聊多生产者多消费者模式，也就是多条生产线程配合多条消费线程。既然这样的话我们先把上面的代码Single_Producer_Consumer.java类修改成新类，大部分代码不变，仅新增2条线程去跑，一条t1的生产  共享资源类KaoYaResource不作更改，代码如下：

1. package com.zejian.test;  
2. /** 
3.  * @author zejian 
4.  * @time 2016年3月13日 上午10:35:05 
5.  * @decrition 多生产者多消费者模式 
6.  */  
7. public class Mutil_Producer_Consumer {  
8.       
9.     public static void main(String[] args)   
10.     {  
11.         KaoYaResource r = new KaoYaResource();  
12.         Mutil_Producer pro = new Mutil_Producer(r);  
13.         Mutil_Consumer con = new Mutil_Consumer(r);  
14.         //生产者线程  
15.         Thread t0 = new Thread(pro);  
16.         Thread t1 = new Thread(pro);  
17.         //消费者线程  
18.         Thread t2 = new Thread(con);  
19.         Thread t3 = new Thread(con);  
20.         //启动线程  
21.         t0.start();  
22.         t1.start();  
23.         t2.start();  
24.         t3.start();  
25.     }  
26. }  
27. /** 
28.  * @author zejian 
29.  * @time 2016年3月12日 下午11:02:22 
30.  * @decrition 生产者线程 
31.  */  
32. class Mutil_Producer implements Runnable  
33. {  
34.     private KaoYaResource r;  
35.     Mutil_Producer(KaoYaResource r)  
36.     {  
37.         this.r = r;  
38.     }  
39.     public void run()  
40.     {  
41.         while(true)  
42.         {  
43.             r.product("北京烤鸭");  
44.         }  
45.     }  
46. }  
47. /** 
48.  * @author zejian 
49.  * @time 2016年3月12日 下午11:02:05 
50.  * @decrition 消费者线程 
51.  */  
52. class Mutil_Consumer implements Runnable  
53. {  
54.     private KaoYaResource r;  
55.     Mutil_Consumer(KaoYaResource r)  
56.     {  
57.         this.r = r;  
58.     }  
59.     public void run()  
60.     {  
61.         while(true)  
62.         {  
63.             r.consume();  
64.         }  
65.     }  
66. }  

1. package com.zejian.test;  
2. /** 
3.  * @author zejian 
4.  * @time 2016年3月12日 下午10:44:25 
5.  * @decrition 烤鸭资源 
6.  */  
7. public class KaoYaResource {  
8.       
9.     private String name;  
10.     private int count = 1;//烤鸭的初始数量  
11.     private boolean flag = false;//判断是否有需要线程等待的标志  
12.       
13.     /** 
14.      * 生产烤鸭 
15.      */  
16.     public synchronized void product(String name){  
17.         if(flag){  
18.             //此时有烤鸭，等待  
19.             try {  
20.                 this.wait();  
21.             } catch (InterruptedException e) {  
22.                 e.printStackTrace();  
23.             }  
24.         }  
25.         this.name=name+count;//设置烤鸭的名称  
26.         count++;  
27.         System.out.println(Thread.currentThread().getName()+"...生产者..."+this.name);  
28.         flag=true;//有烤鸭后改变标志  
29.         notifyAll();//通知消费线程可以消费了  
30.     }  
31.       
32.     /** 
33.      * 消费烤鸭 
34.      */  
35.     public synchronized void consume(){  
36.         if(!flag){//如果没有烤鸭就等待  
37.             try{this.wait();}catch(InterruptedException e){}  
38.         }  
39.         System.out.println(Thread.currentThread().getName()+"...消费者........"+this.name);//消费烤鸭1  
40.         flag = false;  
41.         notifyAll();//通知生产者生产烤鸭  
42.     }  
43. }  

分析：确实，我们对共享数据也采用了同步措施，而且也应用了等待/通知机制，但是这样的措施只在单生产者单消费者的情况下才能正确应用，但从运行结果来看，我们之前的单生产者单消费者安全处理措施就不太适合多生产者多消费者的情况了。那么问题出在哪里？可以明确的告诉大家，肯定是在资源共享类，下面我们就来分析问题是如何出现，又该如何解决？直接上图

1. package com.zejian.test;  
2. /** 
3.  * @author zejian 
4.  * @time 2016年3月12日 下午10:44:25 
5.  * @decrition 烤鸭资源 
6.  */  
7. public class KaoYaResource {  
8.       
9.     private String name;  
10.     private int count = 1;//烤鸭的初始数量  
11.     private boolean flag = false;//判断是否有需要线程等待的标志  
12.     /** 
13.      * 生产烤鸭 
14.      */  
15.     public synchronized void product(String name){  
16.         while(flag){  
17.             //此时有烤鸭，等待  
18.             try {  
19.                 this.wait();  
20.             } catch (InterruptedException e) {  
21.                 e.printStackTrace();  
22.             }  
23.         }  
24.         this.name=name+count;//设置烤鸭的名称  
25.         count++;  
26.         System.out.println(Thread.currentThread().getName()+"...生产者..."+this.name);  
27.         flag=true;//有烤鸭后改变标志  
28.         notifyAll();//通知消费线程可以消费了  
29.     }  
30.       
31.     /** 
32.      * 消费烤鸭 
33.      */  
34.     public synchronized void consume(){  
35.         while(!flag){//如果没有烤鸭就等待  
36.             try{this.wait();}catch(InterruptedException e){}  
37.         }  
38.         System.out.println(Thread.currentThread().getName()+"...消费者........"+this.name);//消费烤鸭1  
39.         flag = false;  
40.         notifyAll();//通知生产者生产烤鸭  
41.     }  
42. }  

从代码中可以看到，我们创建了producer_con 和consumer_con两个条件对象，分别用于监听生产者线程和消费者线程，在product()方法中，我们获取到锁后，

同步嵌套是产生死锁的常见情景，从上面的代码中我们可以看出，当t1线程拿到锁A后，睡眠2秒，此时线程t2刚好拿到了B锁，接着要获取A锁，但是此时A锁正好被t1线程持有，因此只能等待t1线程释放锁A，但遗憾的是在t1线程内又要求获取到B锁，而B锁此时又被t2线程持有，到此结果就是t1线程拿到了锁A同时在等待t2线程释放锁B，而t2线程获取到了锁B也同时在等待t1线程释放锁A，彼此等待也就造成了线程死锁问题。虽然我们现实中一般不会向上面那么写出那样的代码，但是有些更为复杂的场景中，我们可能会遇到这样的问题，比如t1拿了锁之后，因为一些异常情况没有释放锁（死循环），也可能t1拿到一个数据库锁，释放锁的时候抛出了异常，没有释放等等，所以我们应该在写代码的时候多考虑死锁的情况，这样才能有效预防死锁程序的出现。下面我们介绍一下避免死锁的几个常见方法：

1. package com.zejian.test;  
2. /** 
3.  * @author zejian 
4.  * @time 2016年3月13日 下午4:10:03 
5.  * @decrition join案例 
6.  */  
7. public class JoinDemo {  
8.       
9.     public static void main(String[] args) {  
10.         Thread previous = Thread.currentThread();  
11.         for(int i=0;i<10;i++){  
12.             //每个线程拥有前一个线程的引用。需要等待前一个线程终止，才能从等待中返回  
13.             Thread thread=new Thread(new Domino(previous),String.valueOf(i));  
14.             thread.start();  
15.             previous=thread;  
16.         }  
17.         System.out.println(Thread.currentThread().getName()+" 线程结束");  
18.     }  
19. }  
20. class Domino implements Runnable{  
21.     private Thread thread;  
22.     public Domino(Thread thread){  
23.         this.thread=thread;  
24.     }  
25.       
26.     @Override  
27.     public void run() {  
28.         try {  
29.             thread.join();  
30.         } catch (InterruptedException e) {  
31.             e.printStackTrace();  
32.         }  
33.         System.out.println(Thread.currentThread().getName()+" 线程结束");  
34.     }  
35.       
36. }