线程间的通信

一，概述。 

　　1.什么叫做线程间通信： 在1个进程中，线程往往不是孤立存在的，线程之间需要一些协调通信，来共同完成一件任务。也就是通过一定的方法来实现线程间的“交流”。

　　2.线程间通信的体现：

　　　　- 1个线程传递数据给另1个线程

　　　　- 在1个线程中执行完特定任务后，转到另1个线程继续执行任务

二，线程通信的方法。

　　Object类中相关的方法有两个notify方法和三个wait方法：notify() / notifyAll() / wait()

　　因为wait和notify方法定义在Object类中，因此会被所有的类所继承。这些方法都是final的，即它们都是不能被重写的，不能通过子类覆写去改变它们的行为。

　　1.wait()方法。

　　语法：锁对象.wait()

　　特点：wait()方法的调用使得当前线程必须要等待，直到另外一个线程调用notify()或者notifyAll()方法(注意必须调用notify/notifyAll方法才能唤醒)。

　　　　    wait()方法的调用必须在同步的前提下。（因为该方法是要用锁对象调用，而只有在同步的情况下才有锁）

　　　　    wait()方法的调用会导致锁的释放。

　　线程调用wait()方法，释放它对锁的拥有权，然后等待另外的线程来通知它（通知的方式是notify()或者notifyAll()方法），这样它才能重新获得锁的拥有权和恢复执行。要确保调用wait()方法的时候拥有锁，即，wait()方法的调用必须放在synchronized方法或synchronized块中。

　　一个小比较：

　　当线程调用了wait()方法时，它会释放掉对象的锁。

　　另一个会导致线程暂停的方法：Thread.sleep()，它会导致线程睡眠指定的毫秒数，但线程在睡眠的过程中是不会释放掉对象的锁的

　　2.notify和notifyAll()

　　语法：锁对象.notify()/notifyAll()

　　特点：notify()方法的调用可以唤醒当前锁对象下等待的另一个单个线程。优先级较高的优先唤醒，如果优先级一样，则随机唤醒。notifyAll()方法的调用可以唤醒当前锁对象下等待的所有线程。

　　　　　notify()和notifyAll()方法必须在同步的前提下使用（也就是notify方法调用必须放在synchronized方法或synchronized块中）。

　　　　　被唤醒的线程是不能被执行的，需要等到当前线程放弃这个对象的锁，也就是想要唤醒其他线程，说光调用notify()不行，还必须要调用wait()方法让当前线程释放锁对象，当另外一个线程获得了锁对象即可以执行。

　　注意：wait() / notify() / notifyAll()方法使用的锁对象必须和同步代码块中的锁对象是同一个，否则报异常！！！

 

 【代码演示】：线程间通信。

class Bank1 {//公共资源
    int total=100;
}
class PresonA implements Runnable{
    Bank1  b;
    //因为要确保两个用户使用的是同一家银行，所以在主函数中new一个银行，然后通过构造函数将这一银行传递给这两个用户
    public PresonA(Bank1 b){
        this.b=b;//将银行的引用传给两个用户
    }
    @Override
    public void run() {
        while (true){
            synchronized (b){//同步代码块，因为要确保两个用户使用的是同一个锁，所以选择银行对象作为锁
                if(b.total>=0){//打钱，当卡里钱大于0，就唤醒另一个线程来取钱
                    b.notify();//唤醒另一个线程来取钱，注意该方法是要用锁对象调用的
                    try {
                        b.wait();//接着将自己睡眠，然后把锁释放给两一个线程
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                b.total=b.total+100;//A先存了100
                System.out.println("A存了100，目前存款为："+b.total);
            }
        }
    }
}
class PresonB implements Runnable{
    Bank1  b;
    public PresonB(Bank1 b){
        this.b=b;
    }
    @Override
    public void run() {
        while (true){
            synchronized (b){
                if(b.total<=0){//取钱，当卡里钱小于0，就唤醒另一个线程来存钱
                    b.notify();//唤醒另一个线程
                    try {
                        b.wait();//将自己睡眠
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                b.total=b.total-100;
                System.out.println("****B取了100，目前存款为："+b.total);
            }
        }
    }
}
public class CommunicationDemo {
    public static void main(String[] args) {
        Bank1 b=new Bank1();//作为公共资源传递给两个用户
        new Thread(new PresonA(b)).start();
        new Thread(new PresonB(b)).start();
    }
}

 运行结果：

　　【代码演示】：生产者与消费者 

class Resource{
    int count=0;//商品库存数
}
class Producer implements Runnable{
    Resource r;
    public Producer(Resource r){
        this.r=r;
    }
    public void run(){
        while (true){
            synchronized (r){
                if(r.count>0){
                    try {
                        r.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("生产了一件商品，此时商品数为："+(++r.count));
                r.notify();
            }
        }
    }
}
class Consumer implements Runnable{
    Resource r;
    public Consumer(Resource r){
        this.r=r;
    }
    public void run(){
        while (true){
            synchronized (r){
                if(r.count<=0){
                    try {
                        r.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("消费了一件商品，此时商品数为："+(--r.count));
                r.notify();
            }
        }
    }
}
public class ProducerConsumerDemo {
    public static void main(String[] args) {
        Resource r=new Resource();
        new Thread(new Producer(r)).start();
        new Thread(new Consumer(r)).start();
    }
}

运行结果：

 　　这是在只有两个线程在运行时的结果。如果有四个线程在同时运行呢？（两个生产者两个个消费者）

 　　会发现运行结果是混乱的，为什么这样？？我们先来分析一下这个运行的过程，假设是0号线程（生产者）先获得了CPU的执行权，于是它生产了一个商品，然后接着调用了notify()方法来唤醒其他线程，假设这次随机唤醒的是1号线程（生产者），虽然1号线程这时被唤醒了，但是由于没有CPU 的执行权，1号线程还在运行不了，在进行第二次while循环时，由于判断资源数是大于0的，所以调用了wait()方法，此时0号线程进行等待，并释放了CPU 的执行权，由于被唤醒的只有1号线程，所以1号线程获得了CPU的执行权开始运行，当进入while循环后，判断资源数发现是大于0的，所以1号线程也被挂起进行等代，此时只剩下2号线程和3号线程（消费者），假设2线程先获得CPU执行权，进行判断满足条件，于是就消费了一个商品，然后调用了notify()方法，因为0号线程先进入线程池，所以此时先唤醒的是0号线程，在2号线程在进行第二次while循环时，由于不满足条件，所以调用了wait()方法，此时2号线程进行等待，由于0号线程已被唤醒，所以0号线程接着被锁之前的代码接着运行，生产了一个商品，然后唤醒了1号线程，当0号线释放掉CPU后，1号线程也接着被锁之前的代码进行运算，没有进行判断就直接生产了一个商品。

　　由于线程在被唤醒后是接着被冻结之前的代码接着运行的，所以唤醒之后不会进行判断，就直接生产或消费了。所以就会出现问题。

　　解决的方法就是：就是让各个线程在被唤醒之后仍然进行条件判断，所以将if改为while，同时将notify()改为notifyAll(),否则会发生死锁情况。

　　定义while判断标记：让被唤醒的线程再一次判断标记。

　　定义notifyAll()：因为需要唤醒对方线程。如果只要notify，容易出现只唤醒本方线程的情况，导致程序中的所有都等待。

改过之后运行的结果：

1、 总结notify()和notifyAll()的区别与联系

1） notify只是唤醒一个正在wait当前对象锁的线程，而notifyAll唤醒所有。值得注意的是：notify是本地方法，具体唤醒哪一个线程由虚拟机控制；如果有多个线程等待，则线程规划器任意挑选出其中一个wait()状态的线程来发出通知

2） 当有线程调用了对象的notifyAll()方法（唤醒所有wait线程）或 notify()方法（只随机唤醒一个 wait 线程），被唤醒的的线程便会进入该对象的锁池中，锁池中的线程会去竞争该对象锁。也就是说，调用了notify后只有一个线程会由等待池进入锁池，而notifyAll会将该对象等待池内的所有线程移动到锁池中，等待锁竞争

3） 调用notify和notifyAll方法后，当前线程并不会立即放弃锁的持有权，而必须要等待当前同步代码块执行完才会让出锁

4） 优先级高的线程竞争到对象锁的概率大，假若某线程没有竞争到该对象锁，它还会留在锁池中，唯有线程再次调用wait()方法，它才会重新回到等待池中。而竞争到对象锁的线程则继续往下执行，直到执行完了synchronized代码块，它会释放掉该对象锁，这时锁池中的线程会继续竞争该对象锁。

 锁池：获取同一把锁的线程，在为抢夺锁时会进入到锁池
等待池：调用wait操作的线程，会释放掉锁，进入到该对象的等待池中

三，线程另一种通信的方法---Condition,Lock1的具体使用。

　　使用notifyAll()方法是将所有被冻结的线程都唤醒，那如果只唤醒对方线程该怎么办？

　　在jdk1.5之后添加了java.util.concurrent.locks包，在此包中有Condition,Lock,ReadWriteLock接口供使用。与synchronized相比，lock更加灵活，使用更加广泛。

　　其中Lock代替了同步代码块synchronized；Condition的await(),signal(),signalAll()代替了Object中的wait(),notify(),notifyAll()方法。

public interface Condition{
　　void await() throws InterruptedException;//使线程进入休眠，类似于wait()
　　void awaitUninterruptibly();
　　long awaitNanos(long nanosTimeout) throws InterruptedException;
　　boolean await(long time,TimeUnit unit) throws InterruptedException;
　　boolean awaitUnit(Date deadline) throws InterruptedException;
　　void  signal();//唤醒因await进入休眠的一个线程，类似于notify();
　　void  signalAll();//唤醒因await进入休眠的所有线程，类似于notifyAll();
}

　　注意：1.Condition需要和lock结合使用。且lock和Condition必须是同一个ReentrantLock下的，否则会报iLLegalMonitorStateException异常。

　　　　　2.作用于同一个Condition实例下的线程之间才能进行通信。

　　　　Lock lock=new ReentrantLock();
　　　　Condition condition=lock.newCondition();

　　【代码演示】：多个线程间的通信。 （使用signalAll方法，唤醒所有线程）

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
class Resource{
    int count=1;//商品库存数
    Lock lock=new ReentrantLock();
    Condition condition=lock.newCondition();
}
class Producer implements Runnable{
    Resource r;
    Lock lock;
    Condition condition;
    public Producer(Resource r){
        this.r=r;
        this.lock=r.lock;
        this.condition=r.condition;
    }
    public void run(){
            lock.lock();//加锁，如果获取失败，将进入休眠状态
            try {
                while(true){
                    while (r.count>0){
                        condition.await();//将自己阻塞
                    }
                    System.out.println(Thread.currentThread().getName()+"生产了一件商品，此时商品数为："+(++r.count));
                    condition.signalAll();//唤醒其他所有线程
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                lock.unlock();//释放锁
            }
    }
}
class Consumer implements Runnable{
    Resource r;
    Lock lock;
    Condition condition;
    public Consumer(Resource r){
        this.r=r;
        this.lock=r.lock;
        this.condition=r.condition;
    }
    public void run(){
            lock.lock();//加锁
            try {
                while(true){
                    while (r.count<=0){
                        condition.await();
                    }
                    System.out.println(Thread.currentThread().getName()+"消费了一件商品，此时商品数为："+(--r.count));
                    condition.signalAll();
                }
            } catch (InterruptedException e) {
                 e.printStackTrace();
            }finally {
                 lock.unlock();//释放锁（）
            }
    }
}
public class ProducerConsumerDemo {
    public static void main(String[] args) {
        Resource r=new Resource();
        new Thread(new Producer(r)).start();
        new Thread(new Producer(r)).start();
        new Thread(new Consumer(r)).start();
        new Thread(new Consumer(r)).start();
    }
}

　　在Condition中，用await()替换wait()，用signal()替换notify()，用signalAll()替换notifyAll()，传统线程的通信方式，使用Condition都可以实现，这里注意，Condition是被绑定到Lock上的，要创建一个Lock的Condition必须用newCondition()方法。

 　　这样看来，Condition和传统的线程通信可能没什么区别，但Condition的强大之处在于它可以为多个线程间建立不同的Condition，用下面这个代码演示一下。

　　【代码演示】：多个线程间的通信。（使用signalAll()方法，只唤醒对方的线程）

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
class Resource{
    int count=0;//商品库存数
    Lock lock=new ReentrantLock();
    Condition condition_con=lock.newCondition();
    Condition condition_pro=lock.newCondition();
}
class Producer implements Runnable {
    Resource r;
    Lock lock;
    Condition condition_con;
    Condition condition_pro;
    public Producer(Resource r) {
        this.r = r;
        this.lock = r.lock;
        this.condition_con = r.condition_con;
        this.condition_pro = r.condition_pro;
    }
    public void run() {
        lock.lock();//加锁
        try {
            while(true){

                while (r.count > 0) {
                    condition_pro.await();
                }
                System.out.println(Thread.currentThread().getName() + "生产了一件商品，此时商品数为：" + (++r.count));
                condition_con.signal();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
            //释放锁,因为await方法发生异常时，程序停止运行，则就会一直持有锁，而造成死锁。所以将unlock放在finally中
        }
    }
}

class Consumer implements Runnable{
    Resource r;
    Lock lock;
    Condition condition_con;
    Condition condition_pro;
    public Consumer(Resource r){
        this.r=r;
        this.lock=r.lock;
        this.condition_con=r.condition_con;
        this.condition_pro=r.condition_pro;
    }
    public void run(){
        lock.lock();//加锁
            try {
                while (true){
                    while (r.count<=0) {
                        condition_con.await();
                    }
                    System.out.println(Thread.currentThread().getName()+"消费了一件商品，此时商品数为："+(--r.count));
                    condition_pro.signal();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                lock.unlock();//释放锁
            }
    }
}
public class ProducerConsumerDemo {
    public static void main(String[] args) {
        Resource r=new Resource();
        new Thread(new Producer(r)).start();
        new Thread(new Producer(r)).start();
        new Thread(new Consumer(r)).start();
        new Thread(new Consumer(r)).start();
    }
}

 四，线程通信的方法--CountDownLatch方式

• CountDownLatch是在java1.5被引入的，存在java.util.concurrent包下。
• CountDownLatch能够使一个线程等待其他线程完成各自的工作之后，在执行。
• CountDownLatch是通过一个计数器来实现的，计数器的初始值设置为要等待的线程的数量。每当一个线程完成自己的任务后，计数器的值就会减一，当计数器的值到达0时，它表示所有线程已经完成了任务，然后在闭锁上等待的线程就可以恢复执行任务。

　　【代码演示】：教练需要等待所有运动员到齐且准备好之后，教练才能开始训练。

import java.util.concurrent.CountDownLatch;
public class CoachRacerDemo {
    private CountDownLatch countDownLatch=new CountDownLatch(3);//设置要等待的运动员是3个
    /**
     * 运动员方法
     */
    public void racer(){
        //获取运动员的名称
        String name=Thread.currentThread().getName();
        //运动员开始准备：打印准备信息
        System.out.println(name+"正在准备。。。");
        //准备中
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //准备完毕：打印准备完毕的信息
        System.out.println(name+"准备完毕");
        countDownLatch.countDown();
    }

    /**
     *教练方法
     */
    public void coach(){
        //获取教练线程的名称
        String name=Thread.currentThread().getName();
        //教练等待运动员准备完毕
        System.out.println(name+"等待运动员准备");
        //等待中。。。。
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //运动员都准备好了，教练开始训练
        System.out.println("所有运动员都准备完毕"+name+"开始训练");
    }
    public static void main(String[] args) {
        //创建CoachRacerDemo实例
        CoachRacerDemo coachRacerDemo=new CoachRacerDemo();
        //创建三个运动员线程
        Thread thread1=new Thread(new Runnable() {
            @Override
            public void run() {
                coachRacerDemo.racer();
            }
        },"运动员1");
        Thread thread2=new Thread(new Runnable() {
            @Override
            public void run() {
                coachRacerDemo.racer();
            }
        },"运动员2");
        Thread thread3=new Thread(new Runnable() {
            @Override
            public void run() {
                coachRacerDemo.racer();
            }
        },"运动员3");
        //创建一个教练线程
        Thread thread4=new Thread(new Runnable() {
            @Override
            public void run() {
                coachRacerDemo.coach();
            }
        },"教练");
        thread4.start();
        thread1.start();
        thread2.start();
        thread3.start();

    }
}

　　运行结果：

五，线程通信的方法--CyclicBarrier方法

• CyclicBarrier是在Java1.5被引入的，存在于java.util.concurrent包下。
• CyclicBarrier实现让一组线程等待至某种状态之后在全部同时执行。
• CyclicBarrier底层是基于ReentrantLock和Condition实现的。

 【代码演示】：类似于运动员比赛，当所有运动员都准备好之后，在枪声一响，所有运动员立马同时起跑。

import java.util.Date;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class ThreadRunnerDemo {
    private CyclicBarrier cyclicBarrier=new CyclicBarrier(4);//设置线程数量
    public void StartRun(){
        //获取线程的信息
        String name=Thread.currentThread().getName();
        //调用CyclicBarrier的await方法开始准备
        try {
            cyclicBarrier.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (BrokenBarrierException e) {
            e.printStackTrace();
        }
        System.out.println(name+"已经准备好"+new Date().getTime());
    }
    public static void main(String[] args) {
        final ThreadRunnerDemo threadRunnerDemo=new ThreadRunnerDemo();
        Thread thread1=new Thread(new Runnable() {
            @Override
            public void run() {
                threadRunnerDemo.StartRun();
            }
        },"运动员1号");
        Thread thread2=new Thread(new Runnable() {
            @Override
            public void run() {
                threadRunnerDemo.StartRun();
            }
        },"运动员2号");
        Thread thread3=new Thread(new Runnable() {
            @Override
            public void run() {
                threadRunnerDemo.StartRun();
            }
        },"运动员3号");
        Thread thread4=new Thread(new Runnable() {
            @Override
            public void run() {
                threadRunnerDemo.StartRun();
            }
        },"运动员4号");
        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();
    }
}

　　运行结果： 

 

 　　根据后面的时间，我们可以确定四个线程是同时启动的。

 六，线程间通信的方法--Semaphore方法

•  Semaphore是在Java1.5被引入的，存在于java.util.concurrent包下。
•  Semaphore用于控制对某组资源的访问权限。

【代码演示】：8个工人使用3台机器工作，机器为互斥资源（即每次只能一个人使用）。

import java.util.concurrent.Semaphore;
public class WorkerDemo {
    static class Work implements Runnable{
        private int workId=0;//工人的工号
        private Semaphore machineNumber;//机器数量
        public Work(int workId,Semaphore machineNumber){
            this.workId=workId;
            this.machineNumber=machineNumber;
        }
        @Override
        public void run() {
            //工人要去获取机器
            try {
                machineNumber.acquire();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //打印当前工作的工人的信息
            String name=Thread.currentThread().getName();
            System.out.println(name+"获取机器，开始工作了。。。");
            //工作过程
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //工作完释放机器
            machineNumber.release();
            System.out.println(name+"工作完了，释放机器");
        }
    }
    public static void main(String[] args) {
        int workers=8;//工人数
        Semaphore semaphore=new Semaphore(3);//机器数
        for (int i = 0; i < workers; i++) {
            new Thread(new Work(i,semaphore)).start();
        }
    }
}

运行结果：

面试题：wait和sleep的区别？

面试题：wait和notify的异同？

相同点：

• 都Object中的方法。
• 调用必须在同步的前提下。（因为该方法是要用锁对象调用，而只有在同步的情况下才有锁，也就是notify方法调用必须放在synchronized方法或synchronized块中）。

不同点：

wait():

• wait()方法的调用使得当前线程必须要等待，直到另外一个线程调用notify()或者notifyAll()方法(注意必须调用notify/notifyAll方法才能唤醒)。
• wait()方法的调用会导致锁的释放。

notify():

• notify()方法的调用可以唤醒当前锁对象下等待的另一个单个线程。优先级较高的优先唤醒，如果优先级一样，则随机唤醒。notifyAll()方法的调用可以唤醒当前锁对象下等待的所有线程。