java 多线程同步以及线程间通信详解 & 消费者生产者模式 & 死锁 & Thread.join()（多线程编程之二）

TicketDemo类无需变化，运行结果正常（太多不贴了），线程安全问题就此解决。

在Java中内置了语言级的同步原语－synchronized，这个可以大大简化了Java中多线程同步的使用。从JAVA SE1.0开始，java中的每一个对象都有一个内部锁，如果一个方法使用synchronized关键字进行声明，那么这个对象将保护整个方法，也就是说调用该方法线程必须获得内部的对象锁。

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

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

同步的弊端：相对降低了效率，因为同步外的线程的都会判断同步锁。

同步的前提：同步中必须有多个线程并使用同一个锁。

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

在这个类中我们有两个synchronized的同步方法，一个是生产烤鸭的，一个是消费烤鸭的，之所以需要同步是因为我们操作了共享数据count，同时为了保证生产烤鸭后才能消费也就是生产一只烤鸭后才能消费一只烤鸭，我们使用了等待/通知机制，wait()和notify()。当第一次运行生产现场时调用生产的方法，此时有一只烤鸭，即flag=false，无需等待，因此我们设置可消费的烤鸭名称然后改变flag=true，同时通知消费线程可以消费烤鸭了，即使此时生产线程再次抢到执行权，因为flag=true，所以生产线程会进入等待阻塞状态，消费线程被唤醒后就进入消费方法，消费完成后，又改变标志flag=false，通知生产线程可以生产烤鸭了………以此循环。

package com.zejian.test;
/**
 * @author zejian
 * @time 2016年3月12日 下午10:29:12
 * @decrition 单生产者单消费者模式
 */
public class Single_Producer_Consumer {
  
  public static void main(String[] args) 
  {
    KaoYaResource r = new KaoYaResource();
    Producer pro = new Producer(r);
    Consumer con = new Consumer(r);
    //生产者线程
    Thread t0 = new Thread(pro);
    //消费者线程
    Thread t2 = new Thread(con);
    //启动线程
    t0.start();
    t2.start();
  }
}
/**
 * @author zejian
 * @time 2016年3月12日 下午11:02:22
 * @decrition 生产者线程
 */
class Producer implements Runnable
{
  private KaoYaResource r;
  Producer(KaoYaResource r)
  {
    this.r = r;
  }
  public void run()
  {
    while(true)
    {
      r.product("北京烤鸭");
    }
  }
}
/**
 * @author zejian
 * @time 2016年3月12日 下午11:02:05
 * @decrition 消费者线程
 */
class Consumer implements Runnable
{
  private KaoYaResource r;
  Consumer(KaoYaResource r)
  {
    this.r = r;
  }
  public void run()
  {
    while(true)
    {
      r.consume();
    }
  }
}

在这个类中我们创建两个线程，一个是消费者线程，一个是生产者线程，我们分别开启这两个线程用于不断的生产消费，运行结果如下：

package com.zejian.test;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
 * @author zejian
 * @time 2016年3月13日 上午9:55:35
 * @decrition 通过对象锁的方式来实现等待/通知机制
 */
public class KaoyaResourceByLock {
  
  private String name;
  private int count = 1;//烤鸭的初始数量
  private boolean flag = false;//判断是否有需要线程等待的标志
  //创建一个锁对象
  private Lock resourceLock=new ReentrantLock();
  //创建条件对象
  private Condition condition= resourceLock.newCondition();
  /**
   * 生产烤鸭
   */
  public  void product(String name){
    resourceLock.lock();//先获取锁
    try{
      if(flag){
        try {
          condition.await();
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }
      this.name=name+count;//设置烤鸭的名称
      count++;
      System.out.println(Thread.currentThread().getName()+"...生产者..."+this.name);
      flag=true;//有烤鸭后改变标志
      condition.signalAll();//通知消费线程可以消费了
    }finally{
      resourceLock.unlock();
    } 
  }
  
  /**
   * 消费烤鸭
   */
  public  void consume(){
    resourceLock.lock();
    try{
    if(!flag){//如果没有烤鸭就等待
      try{condition.await();}catch(InterruptedException e){}
    }
    System.out.println(Thread.currentThread().getName()+"...消费者........"+this.name);//消费烤鸭1
    flag = false;
    condition.signalAll();//通知生产者生产烤鸭
    }finally{
      resourceLock.unlock();
    }
  }
}

4.2多生产者多消费者模式

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

package com.zejian.test;
/**
 * @author zejian
 * @time 2016年3月13日 上午10:35:05
 * @decrition 多生产者多消费者模式
 */
public class Mutil_Producer_Consumer {
  
  public static void main(String[] args) 
  {
    KaoYaResource r = new KaoYaResource();
    Mutil_Producer pro = new Mutil_Producer(r);
    Mutil_Consumer con = new Mutil_Consumer(r);
    //生产者线程
    Thread t0 = new Thread(pro);
    Thread t1 = new Thread(pro);
    //消费者线程
    Thread t2 = new Thread(con);
    Thread t3 = new Thread(con);
    //启动线程
    t0.start();
    t1.start();
    t2.start();
    t3.start();
  }
}
/**
 * @author zejian
 * @time 2016年3月12日 下午11:02:22
 * @decrition 生产者线程
 */
class Mutil_Producer implements Runnable
{
  private KaoYaResource r;
  Mutil_Producer(KaoYaResource r)
  {
    this.r = r;
  }
  public void run()
  {
    while(true)
    {
      r.product("北京烤鸭");
    }
  }
}
/**
 * @author zejian
 * @time 2016年3月12日 下午11:02:05
 * @decrition 消费者线程
 */
class Mutil_Consumer implements Runnable
{
  private KaoYaResource r;
  Mutil_Consumer(KaoYaResource r)
  {
    this.r = r;
  }
  public void run()
  {
    while(true)
    {
      r.consume();
    }
  }
}

就多了两条线程，我们运行代码看看，结果如下：

package com.zejian.test;
/**
 * @author zejian
 * @time 2016年3月12日 下午10:44:25
 * @decrition 烤鸭资源
 */
public class KaoYaResource {
  
  private String name;
  private int count = 1;//烤鸭的初始数量
  private boolean flag = false;//判断是否有需要线程等待的标志
  
  /**
   * 生产烤鸭
   */
  public synchronized void product(String name){
    if(flag){
      //此时有烤鸭，等待
      try {
        this.wait();
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
    this.name=name+count;//设置烤鸭的名称
    count++;
    System.out.println(Thread.currentThread().getName()+"...生产者..."+this.name);
    flag=true;//有烤鸭后改变标志
    notifyAll();//通知消费线程可以消费了
  }
  
  /**
   * 消费烤鸭
   */
  public synchronized void consume(){
    if(!flag){//如果没有烤鸭就等待
      try{this.wait();}catch(InterruptedException e){}
    }
    System.out.println(Thread.currentThread().getName()+"...消费者........"+this.name);//消费烤鸭1
    flag = false;
    notifyAll();//通知生产者生产烤鸭
  }
}

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

解决后的资源代码如下只将if改为了while：

package com.zejian.test;
/**
 * @author zejian
 * @time 2016年3月12日 下午10:44:25
 * @decrition 烤鸭资源
 */
public class KaoYaResource {
  
  private String name;
  private int count = 1;//烤鸭的初始数量
  private boolean flag = false;//判断是否有需要线程等待的标志
  /**
   * 生产烤鸭
   */
  public synchronized void product(String name){
    while(flag){
      //此时有烤鸭，等待
      try {
        this.wait();
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
    this.name=name+count;//设置烤鸭的名称
    count++;
    System.out.println(Thread.currentThread().getName()+"...生产者..."+this.name);
    flag=true;//有烤鸭后改变标志
    notifyAll();//通知消费线程可以消费了
  }
  
  /**
   * 消费烤鸭
   */
  public synchronized void consume(){
    while(!flag){//如果没有烤鸭就等待
      try{this.wait();}catch(InterruptedException e){}
    }
    System.out.println(Thread.currentThread().getName()+"...消费者........"+this.name);//消费烤鸭1
    flag = false;
    notifyAll();//通知生产者生产烤鸭
  }
}

运行代码，结果如下：

package com.zejian.test;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
 * @author zejian
 * @time 2016年3月13日 下午12:03:27
 * @decrition 通过已有的锁获取两组监视器，一组监视生产者，一组监视消费者。
 */
public class ResourceBy2Condition {
  private String name;
  private int count = 1;
  private boolean flag = false;
  
    //创建一个锁对象。
  Lock lock = new ReentrantLock();
  
  //通过已有的锁获取两组监视器，一组监视生产者，一组监视消费者。
  Condition producer_con = lock.newCondition();
  Condition consumer_con = lock.newCondition();
  
  /**
   * 生产
   * @param name
   */
  public  void product(String name)
  {
    lock.lock();
    try
    {
      while(flag){
        try{producer_con.await();}catch(InterruptedException e){}
      }
      this.name = name + count;
      count++;
      System.out.println(Thread.currentThread().getName()+"...生产者5.0..."+this.name);
      flag = true;
//      notifyAll();
//      con.signalAll();
      consumer_con.signal();//直接唤醒消费线程
    }
    finally
    {
      lock.unlock();
    }
  }
  
  /**
   * 消费
   */
  public  void consume()
  {
    lock.lock();
    try
    {
      while(!flag){
        try{consumer_con.await();}catch(InterruptedException e){}
      }
      System.out.println(Thread.currentThread().getName()+"...消费者.5.0......."+this.name);//消费烤鸭1
      flag = false;
//      notifyAll();
//      con.signalAll();
      producer_con.signal();//直接唤醒生产线程
    }
    finally
    {
      lock.unlock();
    }
  }
}

5.线程死锁

现在我们再来讨论一下线程死锁问题，从上面的分析，我们知道锁是个非常有用的工具，运用的场景非常多，因为它使用起来非常简单，而且易于理解。但同时它也会带来一些不必要的麻烦，那就是可能会引起死锁，一旦产生死锁，就会造成系统功能不可用。我们先通过一个例子来分析，这个例子会引起死锁，使得线程t1和线程t2互相等待对方释放锁。

package com.zejian.test;
/**
 * @author zejian
 * @time 2016年3月13日 下午2:45:52
 * @decrition 死锁示例
 */
public class DeadLockDemo {
  
  private static String A="A";
  private static String B="B";
      
  public static void main(String[] args) {
    DeadLockDemo deadLock=new DeadLockDemo();
    while(true){
      deadLock.deadLock();
    }
  }
  
  private void deadLock(){
    Thread t1=new Thread(new Runnable(){
      @SuppressWarnings("static-access")
      @Override
      public void run() {
        synchronized (A) {
          try {
            Thread.currentThread().sleep(2000);
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
        }
        synchronized(B){
          System.out.println("1");
        }
      }
    });
    
    Thread t2 =new Thread(new Runnable() {  
      @Override
      public void run() {
        synchronized (B) {
          synchronized (A) {
            System.out.println("2");
          }
        }
      }
    });
    
    //启动线程
    t1.start();
    t2.start();
  } 
}

1.避免一个线程同时获取多个锁。

2.避免在一个资源内占用多个 资源，尽量保证每个锁只占用一个资源。

3.尝试使用定时锁，使用tryLock(timeout)来代替使用内部锁机制。

4.对于数据库锁，加锁和解锁必须在一个数据库连接里，否则会出现解锁失败的情况。

5.避免同步嵌套的发生

6.Thread.join()

如果一个线程A执行了thread.join()语句，其含义是：当前线程A等待thread线程终止之后才能从thread.join()返回。线程Thread除了提供join()方法之外，还提供了join(long millis)和join(long millis,int nanos)两个具备超时特性的方法。这两个超时的方法表示，如果线程在给定的超时时间里没有终止，那么将会从该超时方法中返回。下面给出一个例子，创建10个线程，编号0~9，每个线程调用钱一个线程的join()方法，也就是线程0结束了，线程1才能从join()方法中返回，而0需要等待main线程结束。

package com.zejian.test;
/**
 * @author zejian
 * @time 2016年3月13日 下午4:10:03
 * @decrition join案例
 */
public class JoinDemo {
  
  public static void main(String[] args) {
    Thread previous = Thread.currentThread();
    for(int i=0;i<10;i++){
      //每个线程拥有前一个线程的引用。需要等待前一个线程终止，才能从等待中返回
      Thread thread=new Thread(new Domino(previous),String.valueOf(i));
      thread.start();
      previous=thread;
    }
    System.out.println(Thread.currentThread().getName()+" 线程结束");
  }
}
class Domino implements Runnable{
  private Thread thread;
  public Domino(Thread thread){
    this.thread=thread;
  }
  
  @Override
  public void run() {
    try {
      thread.join();
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    System.out.println(Thread.currentThread().getName()+" 线程结束");
  }
  
}

好了，到此本篇结束。