前言
新的一年了，首先是祝大家新年新气象，工作顺利，生活美满 。
万物复苏的一年， 大家都蠢蠢欲动！
金三银四快来了， 机会多不多？
‘’满大街机会‘’
好了不啰嗦，最近有比较多的小伙伴问这个线程交替打印的问题，我就来搞一搞。
正文
一个老掉牙的java面试问题 ， 多线程交替打印。
有打印 ABC 的， 有打印 123 的， 有打印到100的 。
其实都一样。
ps： 最近好多小伙伴问这个，这个题这么热门么？
实例实战思路：
拿一个来做示例， 就交替打印ABC. (文末也说下从1到100的)
一起看看这个小题目 ：
主角
三个线程 线程A 线程 B 线程 C
要做的事
交替打印 A B C
那就是 线程A 负责打印 A ，线程 B 负责打印 B ，线程C 负责打印 C 。
简单分析：
A线程打印完， B线程 打印 ；B线程打印完 ，C 线程打印。
也就是说，这3个线程 ABC ，有顺序/协作 。那么这三个家伙 怎么知道自己要打印东西呢？
那必然是通知 和 等待 。
思路：
三个线程都 准备就绪， 准备大展身手。
接到携带暗号的通知（默认暗号为 A） -> 核对通知的暗号 -> 打印->然后修改暗号-> 发出携带暗号通知（让别的线程认领）
如果接到通知，发现暗号不对，怎么办呢？ 继续进入等待，等待下个通知的到来。
简图：
三个线程的一举一动 ：
ps:
如果是线程A打印完，就把通知暗号改成B，并发出通知；
如果是线程B打印完，就把通知暗号改成C，并发出通知；
同样，如果是线程C打印完，就把通知改回A，继续发通知。
代码 :
写个ReentrantLock条件控制来搞一下。
-
import java.util.concurrent.locks.Lock;
-
import java.util.concurrent.locks.ReentrantLock;
-
import java.util.concurrent.locks.Condition;
-
-
-
public
class
DoTest {
-
-
//控制三个线程 ABC，保证同一时刻只有一个线程工作
-
private
static
Lock
lock
=
new
ReentrantLock(
true);
-
-
// Condition ,控制等待或是 通知
-
private
static
Condition
conditionA
= lock.newCondition();
-
private
static
Condition
conditionB
= lock.newCondition();
-
private
static
Condition
conditionC
= lock.newCondition();
-
-
//默认的通知 暗号 A
-
private
static String CODE=
"A";
-
-
-
public
static
void
main
(String[] args) {
-
-
Thread
A
=
new
Thread(() -> {
-
while (
true) {
-
try {
-
printA();
-
}
catch (InterruptedException e) {
-
e.printStackTrace();
-
}
-
}
-
});
-
-
Thread
B
=
new
Thread(() -> {
-
while (
true) {
-
try {
-
printB();
-
}
catch (InterruptedException e) {
-
e.printStackTrace();
-
}
-
}
-
});
-
-
Thread
C
=
new
Thread(() -> {
-
while (
true) {
-
try {
-
printC();
-
}
catch (InterruptedException e) {
-
e.printStackTrace();
-
}
-
}
-
});
-
-
A.start();
-
B.start();
-
C.start();
-
}
-
-
public
static
void
printA
()
throws InterruptedException {
-
-
//等待
-
lock.lock();
-
try {
-
//核对
-
while (!CODE.equals(
"A")) {
-
//暗号不对，就进入等待
-
conditionA.await();
-
}
-
System.out.println(
"A");
-
//改暗号，通知B
-
CODE =
"B";
-
conditionB.signalAll();
-
}
finally {
-
lock.unlock();
-
}
-
}
-
-
public
static
void
printB
()
throws InterruptedException {
-
lock.lock();
-
try {
-
while (!CODE.equals(
"B")) {
-
conditionB.await();
-
}
-
System.out.println(
"B");
-
//改暗号，通知C
-
CODE =
"C";
-
conditionC.signalAll();
-
}
finally {
-
lock.unlock();
-
}
-
-
}
-
-
public
static
void
printC
()
throws InterruptedException {
-
lock.lock();
-
try {
-
while (!CODE.equals(
"C")) {
-
conditionC.await();
-
}
-
System.out.println(
"C");
-
-
//改暗号，通知A
-
CODE =
"A";
-
conditionA.signalAll();
-
}
finally {
-
lock.unlock();
-
}
-
-
}
-
-
-
}
效果：
可以看到，三个线程 ABC 都开始 无休止的进行了 等待 -接通知 -核对- 打印-改暗号发通知 。
当然如果需要他们不这么无休止，只需要 做一个标识进行判断就好，例如 加在一起已经打印够100次了，就停止 之类的限制值。
举例， 如果交替打印，到100 就停止， 也就是
从1~100 线程A ，线程B ，线程 B 交替打印。
ok,代码稍作调整 ：
加上2个值
一个是打印的数字，这个会一直 +1 输出；
一个是用于线程循环的，之前是while(true) ,这样会一直跑。
如果 终止标记还是false，就继续执行:
每个打印方法都加上判断和累计+1的代码：
看看效果：
整体代码贴一下：
-
import java.util.concurrent.locks.Lock;
-
import java.util.concurrent.locks.ReentrantLock;
-
import java.util.concurrent.locks.Condition;
-
-
-
public
class
DoTest {
-
-
//控制三个线程 ABC，保证同一时刻只有一个线程工作
-
private
static
Lock
lock
=
new
ReentrantLock(
true);
-
-
// Condition ,控制等待或是 通知
-
private
static
Condition
conditionA
= lock.newCondition();
-
private
static
Condition
conditionB
= lock.newCondition();
-
private
static
Condition
conditionC
= lock.newCondition();
-
-
//默认的通知 暗号 A
-
private
static
String
CODE
=
"A";
-
-
//设置初始打印值
-
private
static
int
COUNT_NUM
=
1;
-
-
//线程是否需要终止 标记
-
private
static
volatile
boolean
IS_INTERRUPT
=
false;
-
-
public
static
void
main
(String[] args) {
-
-
Thread
A
=
new
Thread(() -> {
-
while (!IS_INTERRUPT) {
-
try {
-
printA();
-
}
catch (InterruptedException e) {
-
e.printStackTrace();
-
}
-
}
-
});
-
-
Thread
B
=
new
Thread(() -> {
-
while (!IS_INTERRUPT) {
-
try {
-
printB();
-
}
catch (InterruptedException e) {
-
e.printStackTrace();
-
}
-
}
-
});
-
-
Thread
C
=
new
Thread(() -> {
-
while (!IS_INTERRUPT) {
-
try {
-
printC();
-
}
catch (InterruptedException e) {
-
e.printStackTrace();
-
}
-
}
-
});
-
-
A.start();
-
B.start();
-
C.start();
-
}
-
-
public
static
void
printA
()
throws InterruptedException {
-
-
//等待
-
lock.lock();
-
try {
-
if (COUNT_NUM >=
100) {
-
IS_INTERRUPT =
true;
-
return;
-
}
-
//核对
-
while (!CODE.equals(
"A")) {
-
//暗号不对，就进入等待
-
conditionA.await();
-
}
-
System.out.println(
"A, count" + COUNT_NUM);
-
//改暗号，通知B
-
CODE =
"B";
-
COUNT_NUM = COUNT_NUM +
1;
-
conditionB.signalAll();
-
}
finally {
-
lock.unlock();
-
}
-
}
-
-
public
static
void
printB
()
throws InterruptedException {
-
lock.lock();
-
try {
-
-
if (COUNT_NUM >=
100) {
-
IS_INTERRUPT =
true;
-
return;
-
}
-
-
while (!CODE.equals(
"B")) {
-
conditionB.await();
-
}
-
-
System.out.println(
"B, count" + COUNT_NUM);
-
//改暗号，通知C
-
CODE =
"C";
-
COUNT_NUM = COUNT_NUM +
1;
-
-
conditionC.signalAll();
-
}
finally {
-
lock.unlock();
-
}
-
-
}
-
-
public
static
void
printC
()
throws InterruptedException {
-
lock.lock();
-
try {
-
-
if (COUNT_NUM >=
100) {
-
IS_INTERRUPT =
true;
-
return;
-
}
-
-
while (!CODE.equals(
"C")) {
-
conditionC.await();
-
}
-
-
System.out.println(
"C, count" + COUNT_NUM);
-
//改暗号，通知A
-
CODE =
"A";
-
COUNT_NUM = COUNT_NUM +
1;
-
conditionA.signalAll();
-
}
finally {
-
lock.unlock();
-
}
-
-
}
-
-
-
}
可能看到这里，有些初学者会心有疑惑，因为他没了解过 ReentrantLock、Lock 、Condition ，就觉得这个看了不踏实。
没事的，其实只是为了给大家实打实分析思路， 用synchronized 配合 wait() 和 notifyAll 也是一样的。
notifyAll 大不了就全部通知唤醒，然后自己核对暗号再进入等待。
示例，上代码：
-
public
class
DoTest1 {
-
private
volatile
int
COUNT_NUM
=
1;
-
private
volatile
String
CODE
=
"A";
-
private
static
int
oneTimes
=
34;
-
private
static
int
othersTimes
=
33;
-
-
void
onePrint
() {
-
synchronized (
this) {
-
while(!CODE.equals(
"A")) {
-
try {
-
wait();
-
}
catch (InterruptedException e) {
-
e.printStackTrace();
-
}
-
}
-
System.out.println(Thread.currentThread().getName() +
": " + COUNT_NUM);
-
COUNT_NUM++;
-
CODE =
"B";
-
notifyAll();
-
}
-
}
-
void
twoPrint
() {
-
synchronized (
this) {
-
while(!CODE.equals(
"B")) {
-
try {
-
wait();
-
}
catch (InterruptedException e) {
-
e.printStackTrace();
-
}
-
}
-
System.out.println(Thread.currentThread().getName() +
": " + COUNT_NUM);
-
COUNT_NUM++;
-
CODE =
"C";
-
notifyAll();
-
}
-
}
-
void
threePrint
() {
-
synchronized (
this) {
-
while(!CODE.equals(
"C")) {
-
try {
-
wait();
-
}
catch (InterruptedException e) {
-
e.printStackTrace();
-
}
-
}
-
System.out.println(Thread.currentThread().getName() +
": " + COUNT_NUM);
-
COUNT_NUM++;
-
CODE =
"A";
-
notifyAll();
-
}
-
}
-
-
-
public
static
void
main
(String[] args) {
-
DoTest1
printNumber
=
new
DoTest1();
-
new
Thread(() -> {
-
for (
int
i
=
0; i < oneTimes; i++) {
-
printNumber.onePrint();
-
}
-
},
"线程A").start();
-
-
new
Thread(() -> {
-
for (
int
i
=
0; i < othersTimes; i++) {
-
printNumber.twoPrint();
-
}
-
},
"线程B").start();
-
-
new
Thread(() -> {
-
for (
int
i
=
0; i < othersTimes; i++) {
-
printNumber.threePrint();
-
}
-
},
"线程C").start();
-
}
-
}
-
代码简析：
看看效果:
好了，该篇就到这吧。
转载：https://blog.csdn.net/qq_35387940/article/details/128828799
查看评论