java多线程编程之连续打印abc的几种解法
一道编程题如下：
实例化三个线程，一个线程打印a，一个线程打印b，一个线程打印c，三个线程同时执行，要求打印出10个连着的abc。
题目分析：
通过题意我们可以得出，本题需要我们使用三个线程，三个线程分别会打印6次字符，关键是如何保证顺序一定是abc...呢。所以此题需要同步机制来解决问题！
令打印字符A的线程为ThreadA，打印B的ThreadB，打印C的为ThreadC。问题为三线程间的同步唤醒操作，主要的目的就是使程序按ThreadA->ThreadB->ThreadC->ThreadA循环执行三个线程，因此本人整理出了三种方式来解决此问题。
一、通过两个锁(不推荐，可读性和安全性比较差)
package com.demo.test; /**
* 基于两个lock实现连续打印abcabc....
* @author lixiaoxi
*
*/
public class TwoLockPrinter implements Runnable { // 打印次数
private static final int PRINT_COUNT = 10;
// 前一个线程的打印锁
private final Object fontLock;
// 本线程的打印锁
private final Object thisLock;
// 打印字符
private final char printChar; public TwoLockPrinter(Object fontLock, Object thisLock, char printChar) {
this.fontLock = fontLock;
this.thisLock = thisLock;
this.printChar = printChar;
} @Override
public void run() {
// 连续打印PRINT_COUNT次
for (int i = 0; i < PRINT_COUNT; i++) {
// 获取前一个线程的打印锁
synchronized (fontLock) {
// 获取本线程的打印锁
synchronized (thisLock) {
//打印字符
System.out.print(printChar);
// 通过本线程的打印锁唤醒后面的线程
// notify和notifyall均可,因为同一时刻只有一个线程在等待
thisLock.notify();
}
// 不是最后一次则通过fontLock等待被唤醒
// 必须要加判断，不然虽然能够打印10次，但10次后就会直接死锁
if(i < PRINT_COUNT - 1){
try {
// 通过fontLock等待被唤醒
fontLock.wait(); } catch (InterruptedException e) {
e.printStackTrace();
}
} }
}
} public static void main(String[] args) throws InterruptedException {
// 打印A线程的锁
Object lockA = new Object();
// 打印B线程的锁
Object lockB = new Object();
// 打印C线程的锁
Object lockC = new Object(); // 打印a的线程
Thread threadA = new Thread(new TwoLockPrinter(lockC, lockA, 'A'));
// 打印b的线程
Thread threadB = new Thread(new TwoLockPrinter(lockA, lockB, 'B'));
// 打印c的线程
Thread threadC = new Thread(new TwoLockPrinter(lockB, lockC, 'C')); // 依次开启a b c线程
threadA.start();
Thread.sleep(100); // 确保按顺序A、B、C执行
threadB.start();
Thread.sleep(100);
threadC.start();
Thread.sleep(100);
} }
打印结果：
ABCABCABCABCABCABCABCABCABCABC
分析：
此解法为了为了确定唤醒、等待的顺序，每一个线程必须同时持有两个对象锁，才能继续执行。一个对象锁是fontLock，就是前一个线程所持有的对象锁，还有一个就是自身对象锁thisLock。主要的思想就是，为了控制执行的顺序，必须要先持有fontLock锁，也就是前一个线程要释放掉前一个线程自身的对象锁，当前线程再去申请自身对象锁，两者兼备时打印，之后首先调用thisLock.notify()释放自身对象锁，唤醒下一个等待线程，再调用fontLock.wait()释放prev对象锁，暂停当前线程，等待再次被唤醒后进入循环。运行上述代码，可以发现三个线程循环打印ABC，共10次。程序运行的主要过程就是A线程最先运行，持有C，A对象锁，后释放A锁，唤醒B。线程B等待A锁，再申请B锁，后打印B，再释放B锁，唤醒C，线程C等待B锁，再申请C锁，后打印C，再释放C锁，唤醒A。看起来似乎没什么问题，但如果你仔细想一下，就会发现有问题，就是初始条件，三个线程按照A，B，C的顺序来启动，按照前面的思考，A唤醒B，B唤醒C，C再唤醒A。但是这种假设依赖于JVM中线程调度、执行的顺序，所以需要手动控制他们三个的启动顺序，即Thread.Sleep(100)。
二、通过一个ReentrantLock和三个conditon实现(推荐，安全性，性能和可读性较高)
package com.demo.test; import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock; /**
* 基于一个ReentrantLock和三个conditon实现连续打印abcabc...
* @author lixiaoxi
*
*/
public class RcSyncPrinter implements Runnable{ // 打印次数
private static final int PRINT_COUNT = 10;
// 打印锁
private final ReentrantLock reentrantLock;
// 本线程打印所需的condition
private final Condition thisCondtion;
// 下一个线程打印所需要的condition
private final Condition nextCondtion;
// 打印字符
private final char printChar; public RcSyncPrinter(ReentrantLock reentrantLock, Condition thisCondtion, Condition nextCondition,
char printChar) {
this.reentrantLock = reentrantLock;
this.nextCondtion = nextCondition;
this.thisCondtion = thisCondtion;
this.printChar = printChar;
} @Override
public void run() {
// 获取打印锁 进入临界区
reentrantLock.lock();
try {
// 连续打印PRINT_COUNT次
for (int i = 0; i < PRINT_COUNT; i++) {
//打印字符
System.out.print(printChar);
// 使用nextCondition唤醒下一个线程
// 因为只有一个线程在等待，所以signal或者signalAll都可以
nextCondtion.signal();
// 不是最后一次则通过thisCondtion等待被唤醒
// 必须要加判断，不然虽然能够打印10次，但10次后就会直接死锁
if (i < PRINT_COUNT - 1) {
try {
// 本线程让出锁并等待唤醒
thisCondtion.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
} }
} finally {
// 释放打印锁
reentrantLock.unlock();
}
} public static void main(String[] args) throws InterruptedException {
// 写锁
ReentrantLock lock = new ReentrantLock();
// 打印a线程的condition
Condition conditionA = lock.newCondition();
// 打印b线程的condition
Condition conditionB = lock.newCondition();
// 打印c线程的condition
Condition conditionC = lock.newCondition();
// 实例化A线程
Thread printerA = new Thread(new RcSyncPrinter(lock, conditionA, conditionB, 'A'));
// 实例化B线程
Thread printerB = new Thread(new RcSyncPrinter(lock, conditionB, conditionC, 'B'));
// 实例化C线程
Thread printerC = new Thread(new RcSyncPrinter(lock, conditionC, conditionA, 'C'));
// 依次开始A B C线程
printerA.start();
Thread.sleep(100);
printerB.start();
Thread.sleep(100);
printerC.start();
}
}
打印结果：
ABCABCABCABCABCABCABCABCABCABC
分析：
仔细想想本问题，既然同一时刻只能有一个线程打印字符，那我们为什么不使用一个同步锁ReentrantLock？线程之间的唤醒操作可以通过Condition实现，且Condition可以有多个，每个condition.await阻塞只能通过该condition的signal/signalall来唤醒！这是synchronized关键字所达不到的，那我们就可以给每个打印线程一个自身的condition和下一个线程的condition，每次打印字符后，调用下一个线程的condition.signal来唤醒下一个线程，然后自身再通过自己的condition.await来释放锁并等待唤醒。
三、通过一个锁和一个状态变量来实现（推荐）
package com.demo.test; /**
* 基于一个锁和一个状态变量实现连续打印abcabc...
* @author lixiaoxi
*
*/
public class StateLockPrinter {
//状态变量
private volatile int state=0; // 打印线程
private class Printer implements Runnable {
//打印次数
private static final int PRINT_COUNT=10;
//打印锁
private final Object printLock;
//打印标志位 和state变量相关
private final int printFlag;
//后继线程的线程的打印标志位，state变量相关
private final int nextPrintFlag;
//该线程的打印字符
private final char printChar;
public Printer(Object printLock, int printFlag,int nextPrintFlag, char printChar) {
super();
this.printLock = printLock;
this.printFlag=printFlag;
this.nextPrintFlag=nextPrintFlag;
this.printChar = printChar;
} @Override
public void run() {
//获取打印锁 进入临界区
synchronized (printLock) {
//连续打印PRINT_COUNT次
for(int i=0;i<PRINT_COUNT;i++){
//循环检验标志位 每次都阻塞然后等待唤醒
while (state!=printFlag) {
try {
printLock.wait();
} catch (InterruptedException e) {
return;
}
}
//打印字符
System.out.print(printChar);
//设置状态变量为下一个线程的标志位
state=nextPrintFlag;
//注意要notifyall，不然会死锁，因为notify只通知一个，
//但是同时等待的是两个,如果唤醒的不是正确那个就会没人唤醒，死锁了
printLock.notifyAll();
}
}
} } public void test() throws InterruptedException{
//锁
Object lock=new Object();
//打印A的线程
Thread threadA=new Thread(new Printer(lock, 0,1, 'A'));
//打印B的线程
Thread threadB=new Thread(new Printer(lock, 1,2, 'B'));
//打印C的线程
Thread threadC=new Thread(new Printer(lock, 2,0, 'C'));
//一次启动A B C线程
threadA.start();
Thread.sleep(1000);
threadB.start();
Thread.sleep(1000);
threadC.start();
} public static void main(String[] args) throws InterruptedException { StateLockPrinter print = new StateLockPrinter();
print.test();
} }
打印结果：
ABCABCABCABCABCABCABCABCABCABC
分析：
状态变量是一个volatile的整型变量，0代表打印a，1代表打印b，2代表打印c，三个线程都循环检验标志位，通过阻塞前和阻塞后两次判断可以确保当前打印的正确顺序，随后线程打印字符，然后设置下一个状态字符，唤醒其它线程，然后重新进入循环。
补充题
三个Java多线程循环打印递增的数字，每个线程打印5个数值，打印周期1-75，同样的解法：
package com.demo.test; import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock; /**
* 数字打印，三个线程同时打印数字，第一个线程打印12345，第二个线程打印678910 .........
* @author lixiaoxi
*
*/
public class NumberPrinter { //打印计数器
private final AtomicInteger counter=new AtomicInteger(0); private class Printer implements Runnable{
//总共需要打印TOTAL_PRINT_COUNT次
private static final int TOTAL_PRINT_COUNT = 5;
//每次打印PER_PRINT_COUNT次
private static final int PER_PRINT_COUNT = 5;
//打印锁
private final ReentrantLock reentrantLock;
//前一个线程的condition
private final Condition afterCondition;
//本线程的condition
private final Condition thisCondtion; public Printer(ReentrantLock reentrantLock, Condition thisCondtion,Condition afterCondition) {
super();
this.reentrantLock = reentrantLock;
this.afterCondition = afterCondition;
this.thisCondtion = thisCondtion;
} @Override
public void run() {
//进入临界区
reentrantLock.lock();
try {
//循环打印TOTAL_PRINT_COUNT次
for(int i=0;i<TOTAL_PRINT_COUNT;i++){
//打印操作
for(int j=0;j<PER_PRINT_COUNT;j++){
//以原子方式将当前值加 1。
//incrementAndGet返回的是新值（即加1后的值）
System.out.println(counter.incrementAndGet());
}
//通过afterCondition通知后面线程
afterCondition.signalAll();
if(i < TOTAL_PRINT_COUNT - 1){
try {
//本线程释放锁并等待唤醒
thisCondtion.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
} finally {
reentrantLock.unlock();
}
}
} public void test() throws InterruptedException {
//打印锁
ReentrantLock reentrantLock=new ReentrantLock();
//打印A线程的Condition
Condition conditionA=reentrantLock.newCondition();
//打印B线程的Condition
Condition conditionB=reentrantLock.newCondition();
//打印C线程的Condition
Condition conditionC=reentrantLock.newCondition(); //打印线程A
Thread threadA=new Thread(new Printer(reentrantLock,conditionA, conditionB));
//打印线程B
Thread threadB=new Thread(new Printer(reentrantLock, conditionB, conditionC));
//打印线程C
Thread threadC=new Thread(new Printer(reentrantLock, conditionC, conditionA));
// 依次开启a b c线程
threadA.start();
Thread.sleep(100);
threadB.start();
Thread.sleep(100);
threadC.start();
} public static void main(String[] args) throws InterruptedException {
NumberPrinter print = new NumberPrinter();
print.test();
}
}
运行结果：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
java多线程编程之连续打印abc的几种解法的更多相关文章
- java多线程编程题之连续打印abc的几种解法
一道编程题如下: 实例化三个线程,一个线程打印a,一个打印b,一个打印c,三个线程同时执行,要求打印出6个连着的abc 题目分析: 通过题意我们可以得出,本题需要我们使用三个线程,三个线程分别会打印6 ...
- Java多线程编程核心技术
Java多线程编程核心技术 这本书有利于对Java多线程API的理解,但不容易从中总结规律. JDK文档 1. Thread类 部分源码: public class Thread implements ...
- 《Java多线程编程核心技术》知识梳理
<Java多线程编程核心技术> @author ergwang https://www.cnblogs.com/ergwang/ 文章末尾附pdf和png下载链接 第1章 Java多线程技 ...
- Java多线程编程核心技术---学习分享
继承Thread类实现多线程 public class MyThread extends Thread { @Override public void run() { super.run(); Sys ...
- Java多线程编程核心技术---对象及变量的并发访问（二）
数据类型String的常量池特性 在JVM中具有String常量池缓存的功能. public class Service { public static void print(String str){ ...
- Java多线程编程——进阶篇二
一.线程的交互 a.线程交互的基础知识 线程交互知识点需要从java.lang.Object的类的三个方法来学习: void notify() 唤醒在此对象监视器上等待的单个 ...
- Java多线程编程详解
转自:http://programming.iteye.com/blog/158568 线程的同步 由于同一进程的多个线程共享同一片存储空间,在带来方便的同时,也带来了访问冲突这个严重的问题.Ja ...
- 【Todo】【读书笔记】Java多线程编程指南-设计模式篇
下了这本书<Java多线程编程指南-设计模式篇>, 还有另一本<JAVA多线程设计模式>,据说内容有重复,结合着看.
- Java多线程编程总结（学习博客）
Java多线程编程总结:网址:http://lavasoft.blog.51cto.com/62575/27069/
随机推荐
- ASP.NET Core 快速入门（实战篇）
上篇讲了<asp.net core在linux上的环境部署>.今天我们将做几个小玩意实战一下.用到的技术和工具有mysql.websocket.AngleSharp(爬虫html解析).n ...
- mac-os安装autojump
一 概念 autojump是一个命令行工具,它可以使用快捷命令,直接跳转到配置好的目录,而不用管现在身在何处,依赖zsh. 一 安装 安装zsh:sh -c "$(curl -fsSL ht ...
- mysql的学习笔记(七)
1.自定义函数,函数可以返回任意类型的值,同样可接说这些类型的参数. CREATE FUNCTION function_name RETURNS {STRING|INTER|REAL|DECIMAL} ...
- Java泛型的重要目的：别让猫别站在狗队里
<Java编程思想>第四版足足用了75页来讲泛型——厚厚的一沓内容,很容易让人头大——但其实根本不用这么多,只需要一句话:我是一个泛型队列,狗可以站进来,猫也可以站进来,但最好不要既站猫, ...
- Spring之旅第三篇-Spring配置详解
上一篇学习了IOC的概念并初步分析了实现原理,这篇主要学习Spring的配置,话不多说,让我们开始! 一.Bean元素配置 1.1 基本配置 看一个最基本的bean配置 <bean name=& ...
- python默认编码设置
打开python 的gui,输入 1 2 import sys sys.getdefaultencoding() 查询系统当前默认编码 默认情况下显示编码方式为ASCII 在python安装目录下 ...
- Python：黑板课爬虫闯关第一关
近日发现了[黑板课爬虫闯关]这个神奇的网页,练手爬虫非常的合适 地址:http://www.heibanke.com/lesson/crawler_ex00/ 第一关非常的简单 get 请求网址,在响 ...
- C++项目中采用CLR的方式调用C#编写的dll
1.注意事项:在编写C#DLL类库时,最好不要出现相同的命名空间,否则在C++中调用可能会出现编译错误.2.将C#的源码生成的“dll”文件复制到C++项目中的Debug目录下3.将C++项目属性设置 ...
- .NET CAD二次开发学习第一天
基于浩辰CAD2019 需求: 开发线转圆简单命令.命令过程:1) 请选择图中直线(要求支持一次选多个):2) 弹出对话框,输入圆的图层名和半径3) 点对话框中确定按钮,结束命令.命令执行效果:所选每 ...
- Spring Tool Suite4(sts)复制粘贴卡顿(ctrl+v, ctrl+c)、按住ctrl也很卡
最近在看<Spring in Action, Fifth Edition>,下载了Spring Tool Suite4,在使用的过程中发现了一些问题: 只要在复制粘贴(ctrl+c, ct ...