使用condition 实现线程顺序执行
书上给的例子都是ABCABC这种,比较简单,复杂点的如A0B0C0, A0A1A2没有,手动实现下,做个记录
1. A0 A1 A2 A3
public class Demo0 {
private static volatile int nextPrintWho = 0;
public static void main(String[] args) throws InterruptedException, NoSuchFieldException {
ReentrantLock lock = new ReentrantLock();
Condition condition = lock.newCondition();
Runnable runnable = ()-> {
lock.lock();
String name = Thread.currentThread().getName();
final int index = Integer.parseInt(name.substring(name.length() - 1, name.length()));
while (Demo0.nextPrintWho != index) {
try {
condition.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
Demo0.nextPrintWho += 1;
println(Thread.currentThread().getName());
try {
condition.signAll();
}catch (Exception e) {
e.printStackTrace();
}finally {
if(lock.isHeldByCurrentThread()) {
lock.unlock();
}
}
};
int size = 5;
List<Thread> threadList = new ArrayList<>(size);
for(int i=0; i<size; i++) {
threadList.add(new Thread(runnable,"A" + i));
}
threadList.forEach(i->i.start());
}
private static void println(Object object) {
System.out.println(object);
}
}
2.单condition实现ABC ABC ABC
/**
* @author tele
* @Description 使用condition实现顺序启动线程 ABC ABC ABC
* @create 2019-12-24
*/
public class Demo1 { private static volatile int nextPrintWho = 1; public static void main(String[] args) throws InterruptedException, NoSuchFieldException {
ReentrantLock lock = new ReentrantLock();
Condition condition = lock.newCondition(); Runnable runnableA = ()-> {
lock.lock();
while (Demo1.nextPrintWho != 1) {
try {
condition.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
Demo1.nextPrintWho = 2;
println(Thread.currentThread().getName());
try {
condition.signAll();
}catch (Exception e) {
e.printStackTrace();
}finally {
if(lock.isHeldByCurrentThread()) {
lock.unlock();
}
}
}; Runnable runnableB = ()-> {
lock.lock();
while (Demo1.nextPrintWho != 2) {
try {
condition.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
Demo1.nextPrintWho = 3;
println(Thread.currentThread().getName());
try {
condition.signal();
}catch (Exception e) {
e.printStackTrace();
}finally {
if(lock.isHeldByCurrentThread()) {
lock.unlock();
}
}
}; Runnable runnableC = ()-> {
lock.lock();
while (Demo1.nextPrintWho != 3) {
try {
condition.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
Demo1.nextPrintWho = 1;
println(Thread.currentThread().getName());
try {
condition.signal();
}catch (Exception e) {
e.printStackTrace();
}finally {
if(lock.isHeldByCurrentThread()) {
lock.unlock();
}
}
}; for(int i=0; i<5; i++) {
new Thread(runnableA,"A").start();
new Thread(runnableB,"B").start();
new Thread(runnableC,"C").start();
} } private static void println(Object object) {
System.out.println(object);
} }
3.多个condition实现ABC ABC
/**
* @author tele
* @Description 使用多个condition实现顺序启动线程 ABC ABC ABC
* @create 2019-12-24
*/
public class Demo2 { private static volatile int nextPrintWho = 1; public static void main(String[] args) throws InterruptedException, NoSuchFieldException {
ReentrantLock lock = new ReentrantLock();
Condition conditionA = lock.newCondition();
Condition conditionB = lock.newCondition();
Condition conditionC = lock.newCondition(); Runnable runnableA = ()-> {
lock.lock();
while (Demo2.nextPrintWho != 1) {
try {
conditionA.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
Demo2.nextPrintWho = 2;
println(Thread.currentThread().getName());
try {
conditionB.signal();
}catch (Exception e) {
e.printStackTrace();
}finally {
if(lock.isHeldByCurrentThread()) {
lock.unlock();
}
}
}; Runnable runnableB = ()-> {
lock.lock();
while (Demo2.nextPrintWho != 2) {
try {
conditionB.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
Demo2.nextPrintWho = 3;
println(Thread.currentThread().getName());
try {
conditionC.signal();
}catch (Exception e) {
e.printStackTrace();
}finally {
if(lock.isHeldByCurrentThread()) {
lock.unlock();
}
}
}; Runnable runnableC = ()-> {
lock.lock();
while (Demo2.nextPrintWho != 3) {
try {
conditionC.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
Demo2.nextPrintWho = 1;
println(Thread.currentThread().getName());
try {
conditionA.signal();
}catch (Exception e) {
e.printStackTrace();
}finally {
if(lock.isHeldByCurrentThread()) {
lock.unlock();
}
}
}; for(int i=0; i<5; i++) {
new Thread(runnableA,"A").start();
new Thread(runnableB,"B").start();
new Thread(runnableC,"C").start();
} } private static void println(Object object) {
System.out.println(object);
} }
4.A0 B0 C0 A1 B1 C1 A2 B2 C2
/**
* @author tele
* @Description 使用condition实现顺序启动线程 A0 B0 C0 A1 B1 C1 A2 B2 C2
* @create 2019-12-24
*/
public class Demo3 { private static volatile int nextPrintWho = 0; private static volatile int order = 1; private static final int ORDER_A = 1; private static final int ORDER_B = 2; private static final int ORDER_C = 3; public static void main(String[] args) throws InterruptedException, NoSuchFieldException {
ReentrantLock lock = new ReentrantLock();
Condition conditionA = lock.newCondition();
Condition conditionB = lock.newCondition();
Condition conditionC = lock.newCondition(); Runnable runnableA = ()-> {
lock.lock();
String name = Thread.currentThread().getName(); final int index = Integer.parseInt(name.substring(name.length() - 1, name.length())); while (!name.contains("A") || Demo3.nextPrintWho != index || Demo3.order != Demo3.ORDER_A) {
try {
conditionA.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
} Demo3.order = Demo3.ORDER_B;
println(Thread.currentThread().getName());
try {
conditionB.signalAll();
}catch (Exception e) {
e.printStackTrace();
}finally {
if(lock.isHeldByCurrentThread()) {
lock.unlock();
}
}
}; Runnable runnableB = ()-> {
lock.lock();
String name = Thread.currentThread().getName(); final int index = Integer.parseInt(name.substring(name.length() - 1, name.length())); while (!name.contains("B") || Demo3.nextPrintWho != index || Demo3.order != Demo3.ORDER_B) {
try {
conditionB.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
Demo3.order = Demo3.ORDER_C;
println(Thread.currentThread().getName());
try {
conditionC.signalAll();
}catch (Exception e) {
e.printStackTrace();
}finally {
if(lock.isHeldByCurrentThread()) {
lock.unlock();
}
}
}; Runnable runnableC = ()-> {
lock.lock();
String name = Thread.currentThread().getName();
final int index = Integer.parseInt(name.substring(name.length() - 1, name.length()));
while (!name.contains("C") || Demo3.nextPrintWho != index || Demo3.order != Demo3.ORDER_C) {
try {
conditionC.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
Demo3.nextPrintWho += 1;
Demo3.order = Demo3.ORDER_A;
println(Thread.currentThread().getName());
try {
conditionA.signalAll();
}catch (Exception e) {
e.printStackTrace();
}finally {
if(lock.isHeldByCurrentThread()) {
lock.unlock();
}
}
}; for(int i=0; i<5; i++) {
new Thread(runnableA,"A" + i).start();
new Thread(runnableB,"B" + i).start();
new Thread(runnableC,"C" + i).start();
} } private static void println(Object object) {
System.out.println(object);
} }
5.A0 A1 A2 A3 B0 B1 B2 B3
/**
* @author tele
* @Description 使用condition实现顺序启动线程 A0 A1 A2 A3 B0 B1 B2 B3
* @create 2019-12-24
*/
public class Demo4 { private static volatile int nextPrintWho = 0; private static volatile int order = 1; private static final int LIST_SIZE = 5; private static final int ORDER_A = 1; private static final int ORDER_B = 2; private static final int ORDER_C = 3; public static void main(String[] args) throws InterruptedException, NoSuchFieldException {
ReentrantLock lock = new ReentrantLock();
Condition condition = lock.newCondition();
Runnable runnableA = ()-> {
lock.lock();
String name = Thread.currentThread().getName(); final int index = Integer.parseInt(name.substring(name.length() - 1, name.length())); while (!name.contains("A") || Demo4.nextPrintWho != index || Demo4.order != Demo4.ORDER_A) {
try {
condition.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
Demo4.nextPrintWho += 1;
if(Demo4.nextPrintWho == LIST_SIZE) {
Demo4.order = Demo4.ORDER_B;
Demo4.nextPrintWho = 0;
}
println(Thread.currentThread().getName());
try {
condition.signalAll();
}catch (Exception e) {
e.printStackTrace();
}finally {
if(lock.isHeldByCurrentThread()) {
lock.unlock();
}
}
}; Runnable runnableB = ()-> {
lock.lock();
String name = Thread.currentThread().getName(); final int index = Integer.parseInt(name.substring(name.length() - 1, name.length())); while (!name.contains("B") || Demo4.nextPrintWho != index || Demo4.order != Demo4.ORDER_B) {
try {
condition.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
Demo4.nextPrintWho += 1;
if(Demo4.nextPrintWho == LIST_SIZE) {
Demo4.order = Demo4.ORDER_C;
Demo4.nextPrintWho = 0;
}
println(Thread.currentThread().getName());
try {
condition.signalAll();
}catch (Exception e) {
e.printStackTrace();
}finally {
if(lock.isHeldByCurrentThread()) {
lock.unlock();
}
}
}; Runnable runnableC = ()-> {
lock.lock();
String name = Thread.currentThread().getName();
final int index = Integer.parseInt(name.substring(name.length() - 1, name.length()));
while (!name.contains("C") || Demo4.nextPrintWho != index || Demo4.order != Demo4.ORDER_C) {
try {
condition.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
Demo4.order = Demo4.ORDER_C;
Demo4.nextPrintWho += 1;
println(Thread.currentThread().getName());
try {
condition.signalAll();
}catch (Exception e) {
e.printStackTrace();
}finally {
if(lock.isHeldByCurrentThread()) {
lock.unlock();
}
}
}; List<Thread> threadAList = new ArrayList<>(LIST_SIZE);
List<Thread> threadBList = new ArrayList<>(LIST_SIZE);
List<Thread> threadCList = new ArrayList<>(LIST_SIZE); for(int i=0; i<LIST_SIZE; i++) {
threadAList.add(new Thread(runnableA,"A" + i));
threadBList.add(new Thread(runnableB,"B" + i));
threadCList.add(new Thread(runnableC,"C" + i));
} threadAList.forEach(i->i.start());
threadBList.forEach(i->i.start());
threadCList.forEach(i->i.start()); } private static void println(Object object) {
System.out.println(object);
} }
使用condition 实现线程顺序执行的更多相关文章
- Java中如何保证线程顺序执行
只要了解过多线程,我们就知道线程开始的顺序跟执行的顺序是不一样的.如果只是创建三个线程然后执行,最后的执行顺序是不可预期的.这是因为在创建完线程之后,线程执行的开始时间取决于CPU何时分配时间片,线程 ...
- Android中让多个线程顺序执行探究
线程调度是指按照特定机制为多个线程分配CPU的使用权. 有两种调度模型:分时调度模型和抢占式调度模型. 分时调度模型:是指让所有的线程轮流获得cpu的使用权,并且平均分配每个线程占用的CPU的时间片. ...
- T1，T2，T3 三个线程顺序执行
T1,T2,T3 三个线程顺序执行 现在有 T1.T2.T3 三个线程,你怎样保证 T2 在 T1 执行完后执行,T3 在 T2 执行完后执行?(T1->T2->T3) 这个线程问题通常会 ...
- c#线程顺序执行
using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threa ...
- Java中线程顺序执行
现有线程threadone.threadtwo和threadthree,想要的运行顺序为threadone->threadtwo->threadthree,应该如何处理?这里需要用到一个简 ...
- 三个线程T1,T2,T3.保证顺序执行的三种方法
经常看见面试题:有三个线程T1,T2,T3,有什么方法可以确保它们按顺序执行.今天手写测试了一下,下面贴出目前想到的3种实现方式 说明:这里在线程中我都用到了sleep方法,目的是更容易发现问题.之前 ...
- 三个线程abc顺序执行
1.使用synchronized悲观锁(秋招阿里的一个笔试题,应该写的比较复杂,然后就没有然后了o(╥﹏╥)o) public class ThreadThreadp { private int fl ...
- C#之使用AutoResetEvent实现线程的顺序执行
前几天一朋友问我如何实现线程的顺序执行,说真的,虽然看过CLR这本书,也把线程部分拜读了两遍,但是这个问题出来之后还是没有一个思路.今天在搜索资料的时候无意中再次看到AutoResetEvent这个东 ...
- Qt 控制线程的顺序执行（使用QWaitCondition，并且线程类的run函数里记得加exec(),使得线程常驻）
背景项目中用到多线程,对线程的执行顺序有要求: A.一个线程先收数据 B.一个线程处理数据 C.一个线程再将处理后的数据发送出去 要求三个线程按照ABC的顺序循环执行. 思路子类化多线程方法 重写子类 ...
随机推荐
- JavaScript--for in循环访问属性用"."和[ ]的区别
// for in 循环遍历对象的时候// 内部要访问属性的时候不能点语法访问,因为for in 的key是字符串格式// 可通过方括号实现访问 for(var key in manObj) { co ...
- Unity3D 物体旋转之Quaternion.Slerp
实现的功能:1个物体以一定的速度转向目标物体 Quaternion TargetRotation = Quaternion.LookRotation(m_Target.transform.positi ...
- 大话鸿蒙操作系统（一）-- 先聊聊 Fuchsia OS
大话鸿蒙操作系统(一) 第一篇先不聊鸿蒙操作系统,聊聊 Google 的新系统 Fuchsia OS. 先看看 Fuchsia OS 介绍. 为什么 Google 要造新的 Fuchsia OS 操作 ...
- oracle显示和设置环境变量
概述:可以用来控制输出的各种格式. (1)linesize 用于控制每行显示多少个字符,默认80个字符. 基本用法:set linesize 字符数 aql>show linesize sql ...
- Atcoder Tenka1 Programmer Contest D: IntegerotS 【思维题，位运算】
http://tenka1-2017.contest.atcoder.jp/tasks/tenka1_2017_d 给定N,K和A1...AN,B1...BN,选取若干个Ai使它们的或运算值小于等于K ...
- react-cli
更新日志: v1.2.0 ...未完待续 v1.1.0 添加editorconfig 配置ESLint 集成prettier 集成 lint-staged 实现细节: 添加editorconfig e ...
- SQLServer一条SQL查出当月的每一天
from master..spt_values ),,),'2013-02-03')+'-01' as datetime)) 结果: 返回带有年月日的日期 ),),) AS datetime) fro ...
- Top 10 Free IT Certification Training Resources
1. Cybrary Cybrary takes the open source concept and applies it to IT training. Many of the courses ...
- Getting started with the basics of programming exercises_2
1.编写简单power函数 #include<stdio.h> int power(int m, int n); // test power function int main(void) ...
- linux自动挂载NTFS格式移动硬盘
转自:http://blog.163.com/cmh_lj/blog/static/100812304201252522119264/ 由于移动硬盘还有不少的资料,刚插入移动硬盘的时候发现只能自动挂载 ...