java 线程通讯_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 classWaitNotifyRunnable {private Object obj = newObject();private Integer i=0;//单数

public voidodd() {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 voideven(){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 voidmain(String[] args){

final WaitNotifyRunnable runnable= newWaitNotifyRunnable();

Thread t1= new Thread(newRunnable() {public voidrun() {

runnable.odd();

}

},"奇数线程");

Thread t2= new Thread(newRunnable() {public voidrun() {

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 classAwaitSignalRunnable {private Lock lock = newReentrantLock();private Condition condition = lock.newCondition();private Integer i=0;public voidodd() {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 voideven(){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 voidmain(String[] args){

final WaitNotifyRunnable runnable= newWaitNotifyRunnable();

Thread t1= new Thread(newRunnable() {public voidrun() {

runnable.odd();

}

},"奇数线程");

Thread t2= new Thread(newRunnable() {public voidrun() {

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 classCountDown {private Integer i = 0;private CountDownLatch countDownLatch = new CountDownLatch(1);//奇数

public voidodd(){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 voideven(){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 voidmain(String[] args){

final CountDown countDown= newCountDown();

Thread t1= new Thread(newRunnable() {public voidrun() {

countDown.odd();

}

},"奇数");

Thread t2= new Thread(newRunnable() {public voidrun() {

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 classCyclicBarrierDemo {public static voidmain(String[] args){

final CyclicBarrier cyclicBarrier= new CyclicBarrier(3);new Thread(newRunnable() {public voidrun() {

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()+"启动完毕："+newDate().getTime());

}

},"线程1").start();new Thread(newRunnable() {public voidrun() {

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()+"启动完毕："+newDate().getTime());

}

},"线程2").start();new Thread(newRunnable() {public voidrun() {

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()+"启动完毕："+newDate().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 classSemaphoreDemo {static classMachine implements Runnable{private int num;//工号

privateSemaphore semaphore;public Machine(intnum, Semaphore semaphore) {this.num =num;this.semaphore =semaphore;

}public voidrun() {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 voidmain(String[] args){int worker = 8;//工人数

Semaphore semaphore = new Semaphore(3);//机器数

for (int i=0; i< worker; i++){new Thread(newMachine(i, semaphore)).start();

}

}

}

执行效果如下：

1.3. 小结

1.3.1.   sleep和wait区别

1.3.2.   wait和notify区别

wait和notify都是Object中的方法

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

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

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