java多线程（五）线程通讯

1.1. 为什么要线程通信

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

1.2. 线程通讯方式

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

l  休眠唤醒方式：

Object的wait、notify、notifyAll

Condition的await、signal、signalAll

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

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

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

1.2.1.   休眠唤醒方式

Object的wait、notify、notifyAll

package com.signal;

/**
 * @Auther: lanhaifeng
 * @Date: 2019/11/21 0021 09:32
 * @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 t1 = new Thread(new Runnable() {
            public void run() {
                runnable.odd();
            }
        }, "奇数线程");
        Thread t2 = new Thread(new Runnable() {
            public void run() {
                runnable.even();
            }
        }, "偶数线程");

        t1.start();
        t2.start();
    }

}

运行效果：

Condition的await、signal、signalAll

package com.signal;

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

/**
 * @Auther: lanhaifeng
 * @Date: 2019/11/21 0021 09:39
 * @Description:使用Condition的await、signal
 * @statement:
 */
public class AwaitSignalRunnable {

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

    public 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();
            }

        }
    }

    public 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 WaitNotifyRunnable runnable = new WaitNotifyRunnable();
        Thread t1 = new Thread(new Runnable() {
            public void run() {
                runnable.odd();
            }
        }, "奇数线程");
        Thread t2 = new Thread(new Runnable() {
            public void run() {
                runnable.even();
            }
        }, "偶数线程");

        t1.start();
        t2.start();
    }

}

运行效果：

Object和Condition休眠唤醒区别

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

l  object wait()必须要通过Nodify()方法进行唤醒

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

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

1.2.2.   CountDownLatch方式

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

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

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

 

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

示例代码：

package com.signal;

import java.util.concurrent.CountDownLatch;

/**
 * @Auther: lanhaifeng
 * @Date: 2019/11/21 0021 09: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();
    }

}

执行效果：

1.2.3.   CyclicBarrier方式

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

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

CyclicBarrier底层是

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

package com.signal;

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

/**
 * @Auther: lanhaifeng
 * @Date: 2019/11/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();
    }

}

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

1.2.4.   Semaphore方式

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

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

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

package com.signal;

import java.util.concurrent.Semaphore;

/**
 * @Auther: lanhaifeng
 * @Date: 2019/11/21 0021 09: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();
        }
    }

}

执行效果如下：

 

1.3. 小结

1.3.1.   sleep和wait区别

 

1.3.2.   wait和notify区别

wait和notify都是Object中的方法

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

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

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