java多线程05：线程通信

1、为什么要线程通信

多个线程并发执行时，在默认情况下CPU是随机切换线程的，有时我们希望CPU按照我们的规律执行线程，此时就需要线程之间协调通信。

2、线程通讯方式

线程间通信常用方式如下：

l  休眠唤醒方式：Object的wait、notify、notifyAll  和  Condition的await、signal、signalAll

l  CountDownLatch：用于某个线程A等待若干个其他线程执行完之后，它才执行

l  CyclicBarrier：一组线程等待至某个状态之后再全部同时执行

l  Semaphore：用于控制对某组资源的访问权限

2.1 休眠唤醒方式

object的wait、notify、notifyAll

package com.mall.thread;

/**
 * @Auther: mengyang
 * @Date: 2020/1/21 0021 15:05
 * @Description:使用Object类的通信
 * @statement:
 */
public class WaitNotifyRunnable{

    private Object obj = new Object();
    private Integer i = 0;

    //单数
    public void odd(){
        while (i<10){
            synchronized (obj){
                if(i%2 == 1){
                    System.out.println(Thread.currentThread().getName()+"【奇数】："+i);
                    i++;
                    obj.notify();
                }else{
                    try{
                        obj.wait();
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }
                }
            }
        }
    }


    //偶数
    public void even(){
        while (i<10){
            synchronized (obj){
                if(i%2 == 0){
                    System.out.println(Thread.currentThread().getName()+"【偶数】："+i);
                    i++;
                    obj.notify();
                }else{
                    try{
                        obj.wait();
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }
                }
            }
        }
    }

    //测试
    public static void main(String[] args) {
        final WaitNotifyRunnable runnable = new WaitNotifyRunnable();
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                runnable.odd();
            }
        });
        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                runnable.even();
            }
        });

        thread1.start();
        thread2.start();
    }
}

运行效果：

 

Condition的await、signal、signalAll　

package com.mall.thread;

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

/**
 * @Auther: mengyang
 * @Date: 2020/1/21 0021 15:46
 * @Description:使用Condition的await、signal
 * @statement:
 */
public class AwaitSignalRunnable {

    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    private Integer i = 0;


    //奇数
    private void odd(){
        while (i<10){
            lock.lock();
            try{
                if(i%2 == 1){
                    System.out.println(Thread.currentThread().getName()+"【奇数】："+i);
                    i++;
                    condition.signal();
                }else{
                    condition.await();
                }
            }catch (InterruptedException e){
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        }
    }

    //偶数
    private void even(){
        while (i<10){
            lock.lock();
            try{
                if(i%2 == 0){
                    System.out.println(Thread.currentThread().getName()+"【偶数】："+i);
                    i++;
                    condition.signal();
                }else{
                    condition.await();
                }
            }catch (InterruptedException e){
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) {
        final AwaitSignalRunnable runnable = new AwaitSignalRunnable();
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                runnable.odd();
            }
        }, "奇数线程");
        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                runnable.even();
            }
        }, "偶数线程");

        thread1.start();
        thread2.start();
    }
}

　　运行结果：

 

 Object和condition休眠唤醒的区别

l  object wait()必须在synchronized(同步锁) 下使用

l  Object wait()必须要通过notify() 方法唤醒

l condition await() 必须和lock(互斥锁/共享锁) 配合使用

l condition await()必须通过signal()方法唤醒

2.2 CountDownLatch方式

CountDownLatch是在java1.5被引入的，存在于java.util.concurrent包下。

CountDownLatch这个类能够使一个线程等待其他线程完成各自的工作后再执行。

CountDownLatch是通过一个计数器来实现的，计数器的初始值为线程的数量。

 

 每当一个线程完成了自己的任务后，计数器的值就会减1。当计数器值到达0时，它表示所有的线程已经完成了任务，然后在闭锁上等待的线程就可以恢复执行任务。

示例代码：

package com.mall.thread;

import java.util.concurrent.CountDownLatch;

/**
 * @Auther: mengyang
 * @Date: 2019/1/21 0021 16:46
 * @Description:使用CountDownLatch
 * 每当一个线程完成了自己的任务后，计数器的值就会减1。当计数器值到达0时，它表示所有的线程已经完成了任务，然后在闭锁上等待的线程就可以恢复执行任务。
 * @statement:
 */
public class CountDown {

    private Integer i = 0;
    private CountDownLatch countDownLatch = new CountDownLatch(1);
    //奇数
    public void odd(){
        while(i <10){
            if(i%2 == 1){
                System.out.println(Thread.currentThread().getName()+"【奇数】："+i);
                i++;
                countDownLatch.countDown();
            } else {
                try {
                    countDownLatch.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    //偶数
    public void even(){
        while(i <10){
            if(i%2 == 0){
                System.out.println(Thread.currentThread().getName()+"【偶数】："+i);
                i++;
                countDownLatch.countDown();
            } else {
                try {
                    countDownLatch.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    //测试
    public static void main(String[] args){
        final CountDown countDown = new CountDown();
        Thread t1 = new Thread(new Runnable() {
            public void run() {
                countDown.odd();
            }
        },"奇数");
        Thread t2 = new Thread(new Runnable() {
            public void run() {
                countDown.even();
            }
        },"偶数");
        t1.start();
        t2.start();
    }

}

执行效果：

 

 2.3 CyclicBarrier方式

CyclicBarrier是在java1.5被引入的，存在于java.util.concurrent包下。

CyclicBarrier实现让一组线程等待至某个状态之后再全部同时执行。

CyclicBarrier底层是

三个线程同时启动，示例代码如下：

 

package com.mall.thread;

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

/**
 * @Auther: mengyang
 * @Date: 2020/1/21 0021 09:52
 * @Description:使用CyclicBarrier
 * CyclicBarrier实现让一组线程等待至某个状态之后再全部同时执行。
 * @statement:
 */
public class CyclicBarrierDemo {
    public static void main(String[] args){

        final CyclicBarrier cyclicBarrier = new CyclicBarrier(3);

        new Thread(new Runnable() {
            public void run() {
                System.out.println(Thread.currentThread().getName()+"：准备...");
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"启动完毕："+new Date().getTime());
            }
        },"线程1").start();
        new Thread(new Runnable() {
            public void run() {
                System.out.println(Thread.currentThread().getName()+"：准备...");
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"启动完毕："+new Date().getTime());
            }
        },"线程2").start();
        new Thread(new Runnable() {
            public void run() {
                System.out.println(Thread.currentThread().getName()+"：准备...");
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"启动完毕："+new Date().getTime());
            }
        },"线程3").start();
    }

}

执行效果如下：三个线程同时启动

2.4.   Semaphore方式

Semaphore是在java1.5被引入的，存在于java.util.concurrent包下。

Semaphore用于控制对某组资源的访问权限。

工人使用机器工作，示例代码如下：

package com.mall.thread;

import java.util.concurrent.Semaphore;

/**
 * @Auther: mengyang
 * @Date: 2019/1/21 0021 16:56
 * @Description: 使用Semaphore
 * emaphore用于控制对某组资源的访问权限
 * @statement:
 */
public class SemaphoreDemo {
    static class Machine implements Runnable{

        private int num;//工号
        private Semaphore semaphore;

        public Machine(int num, Semaphore semaphore) {
            this.num = num;
            this.semaphore = semaphore;
        }

        public void run() {
            try {
                semaphore.acquire();//请求机器
                System.out.println("工人"+this.num+"请求机器，正在使用机器");
                Thread.sleep(1000);
                System.out.println("工人"+this.num+"使用完毕，已经释放机器");
                semaphore.release();//释放机器
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args){
        int worker = 8;//工人数
        Semaphore semaphore = new Semaphore(3);//机器数
        for (int i=0; i< worker; i++){
            new Thread(new Machine(i, semaphore)).start();
        }
    }

}

执行效果如下：

 

 3、小结

sleep和wait区别

wait和notify区别

wait和notify都是Object中的方法

wait和notify执行前线程都必须获得对象锁

wait的作用是使当前线程进行等待

notify的作用是通知其他等待当前线程的对象锁的线程