- 3，线程间通信
- 3.1使用synchronized锁创建线程进行加一减一操作
- 3.2 使用ReentrantLock锁创建线程进行加一减一
- 4,线程间定制化通信
- 4.1 案例介绍
线程间通信的模型有两种：共享内存和消息传递，以下方式都是基本这两种模型来实现的。我们来基本一道面试常见的题目来分析
多线程编程模板:1.判断 2.干活 3.通知
线程通信的两种写法
- synchronized()中使用wait()和notifyAll()
- lock()中使用Condition()的await()和signalAll()
两种方法的区别（为什么要用lock()替换synchronized()）：lock()的Condition()能够精准通知，精准唤醒
场景-----两个线程，一个线程对当前数值加 1，另一个线程对当前数值减 1,要求
用线程间通信
3.1使用synchronized锁创建线程进行加一减一操作package com;
class Share{
//初始化
private int number=0;
//+1方法
public synchronized void incr(){
//第二部，判断，0 +1
while(number!=0){
try {
this.wait();//等待
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//如果number为0，+1
number++;
System.out.println(Thread.currentThread().getName()+"：："+number);
//通知其他线程,重启其他线程
this.notifyAll();
}
//创建-1方法
public synchronized void decr(){
//第二部，判断，0 +1
while(number!=1){
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//如果number为1，-1
number--;
System.out.println(Thread.currentThread().getName()+"：："+number);
//通知其他线程,重启其他线程
this.notifyAll();
}
}
public class ThreadDemo1 {
public static void main(String[] args) {
Share share = new Share();
new Thread(()->{
for (int i=1;i<=10;i++){
try {
share.incr();
} catch (Exception e) {
e.printStackTrace();
}
}
},"AA").start();
new Thread(()->{
for (int i=1;i<=10;i++){
try {
share.decr();
} catch (Exception e) {
e.printStackTrace();
}
}
},"BB").start();
}
}
结果：
``` BB：：0 AA：：1 BB：：0 AA：：1 BB：：0 AA：：1 BB：：0 AA：：1 BB：：0 ```3.2 使用ReentrantLock锁创建线程进行加一减一
package com;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
//第一步 创建资源类，定义属性和操作方法
class Share {
private int number = 0;
//创建Lock
private ReentrantLock lock = new ReentrantLock();
private Condition condition = lock.newCondition();
//+1
public void incr() throws InterruptedException {
//上锁
lock.lock();
try {
//判断
while (number != 0) {
condition.await();//等待
}
//干活
number++;
System.out.println(Thread.currentThread().getName()+" :: "+number);
//通知
condition.signalAll();//唤醒其他线程
}finally {
//解锁
lock.unlock();
}
}
//-1
public void decr() throws InterruptedException {
lock.lock();
try {
while(number != 1) {
condition.await();
}
number--;
System.out.println(Thread.currentThread().getName()+" :: "+number);
condition.signalAll();
}finally {
lock.unlock();
}
}
}
public class ThreadDemo1 {
public static void main(String[] args) {
Share share = new Share();
new Thread(()->{
for (int i = 1; i <=10; i++) {
try {
share.incr();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"AA").start();
new Thread(()->{
for (int i = 1; i <=10; i++) {
try {
share.decr();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"BB").start();
}
}
注意：
当前线程调用await的时候必须先获取到锁，而执行了await方法之后当前线程回释放该锁并且进入waiting状态，直到其他线程调用该对象的nodify方法或者notifyAll方法。
我们知道Condition中的signal方法和Object类里面的notify方法效果类似，并且调用方法之前需要先获取到锁，Condition中的await方法和Object类里面的wait方法效果类似，也是调用之前需要获取到锁，而调用之后会释放锁。
//使用if做条件判断时可能发生虚假唤醒问题
if(number!=1){
try {
this.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
走到await方法，当前线程挂起，释放掉锁，这时候number变量由于没有被锁住，所以可能会有其他线程将number值修改，导致条件判断产生变化。当另一个线程调用signal唤醒此线程的时候，if和while的区别就体现出来了，如果是if的话线程被唤醒就会直接从await方法往下执行，但是这时候number可能被修改，number!=1条件可能又满足了，这种情况应该是让线程继续挂起，但是用if会唤醒线程，产生了所谓的虚假唤醒，而如果用while的话，线程被唤醒之后还会在执行一次条件判断，确保条件number!=1不满足的时候才唤醒线程。
4,线程间定制化通信 4.1 案例介绍==问题: A 线程打印 5 次 A，B 线程打印 10 次 B，C 线程打印 15 次 C,按照
此顺序循环 10 轮==
//第一步 创建资源类，定义属性和操作方法
class Share {
private int number = 0;
//声明锁
private ReentrantLock lock = new ReentrantLock();
//声明钥匙 A
private Condition conditionA = lock.newCondition();
//声明钥匙 B
private Condition conditionB = lock.newCondition();
//声明钥匙 C
private Condition conditionC = lock.newCondition();
public void printA(int j) {
try {
lock.lock();
while (number != 0) {
conditionA.await();
}
System.out.println(Thread.currentThread().getName() + "输出 A,第" + j + "轮开始");
//输出 3 次 A
for (int i = 0; i < 3; i++) {
System.out.println("A");
}
//开始打印 B
number = 1;
//唤醒 B
conditionB.signal();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void printB(int j) {
try {
lock.lock();
while (number != 1) {
conditionB.await();
}
System.out.println(Thread.currentThread().getName() + "输出 B,第" + j + "轮开始");
//输出 4 次 B
for (int i = 0; i < 4; i++) {
System.out.println("B");
}
//开始打印 C
number = 2;
//唤醒 C
conditionC.signal();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void printC(int j) {
try {
lock.lock();
while (number != 2) {
conditionC.await();
}
System.out.println(Thread.currentThread().getName() + "输出 C,第" + j + " 轮开始");
//输出 5 次 C
for (int i = 0; i < 5; i++) {
System.out.println("C");
}
//开始打印 A
number = 0;
//唤醒 A
conditionA.signal();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
public class ThreadDemo1 {
public static void main(String[] args) {
Share share = new Share();
new Thread(() -> {
for (int i = 1; i <= 3; i++) {
share.printA(i);
}
}, "AA").start();
new Thread(() -> {
for (int i = 1; i <= 3; i++) {
share.printB(i);
}
}, "BB").start();
new Thread(() -> {
for (int i = 1; i <= 3; i++) {
share.printC(i);
}
}, "CC").start();
}
}
