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=; //单数
public void odd() {
while(i<){
synchronized (obj){
if(i% == ){
System.out.println(Thread.currentThread().getName()+"【奇数】："+i);
i++;
obj.notify();
} else {
try {
obj.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
} //双数
public void even(){
while(i<){
synchronized (obj){
if(i% == ){
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=; public void odd() {
while(i<){
lock.lock();
try{
if(i% == ){
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<){
lock.lock();
try{
if(i% == ){
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 = ;
private CountDownLatch countDownLatch = new CountDownLatch();
//奇数
public void odd(){
while(i <){
if(i% == ){
System.out.println(Thread.currentThread().getName()+"【奇数】："+i);
i++;
countDownLatch.countDown();
} else {
try {
countDownLatch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
//偶数
public void even(){
while(i <){
if(i% == ){
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(); 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();
System.out.println("工人"+this.num+"使用完毕，已经释放机器");
semaphore.release();//释放机器
} catch (InterruptedException e) {
e.printStackTrace();
}
}
} public static void main(String[] args){
int worker = ;//工人数
Semaphore semaphore = new Semaphore();//机器数
for (int i=; 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的作用是通知其他等待当前线程的对象锁的线程