java： 线程与volatile、AtomicInteger、ReentrantLock、Condition、Semaphore
参考：
Java 每日算法，三个线程按顺序打印
多个线程按顺序输出
题目一
启动3个线程A、B、C，使A打印0，然后B打印1，然后C打印2，A打印3，B打印4，C打印5，依次类推。
/**
* 启动3个线程A、B、C，使A打印0，然后B打印1，然后C打印2，A打印3，B打印4，C打印5，依次类推。
*/
public class PrintSequenceThread implements Runnable {
private static final Object LOCK = new Object();
//当前即将打印的数字
private static int currentValue = 0;
//当前线程编号，从0开始
private int threadNo;
//线程数量
private int threadCount;
//打印的最大数值
private int maxValue;
public PrintSequenceThread(int threadNo, int threadCount, int maxValue) {
this.threadNo = threadNo;
this.threadCount = threadCount;
this.maxValue = maxValue;
}
@Override
public void run() {
while (true) {
synchronized (LOCK) {
// 判断是否轮到当前线程执行
while (currentValue % threadCount != threadNo) {
if (currentValue > maxValue) {
break;
}
try {
// 如果不是，则当前线程进入wait
LOCK.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 最大值跳出循环
if (currentValue > maxValue) {
break;
}
System.out.println("thread-" + threadNo + " : " + currentValue);
currentValue++;
// 唤醒其他wait线程
LOCK.notifyAll();
}
}
}
public static void main(String[] args) {
int threadCount = 3;
int maxValue = 10;
for (int threadNo = 0; threadNo < threadCount; threadNo++) {
new Thread(new PrintSequenceThread(threadNo, threadCount, maxValue)).start();
}
}
}
//thread-0 : 0
//thread-1 : 1
//thread-2 : 2
//thread-0 : 3
//thread-1 : 4
//thread-2 : 5
//thread-0 : 6
//thread-1 : 7
//thread-2 : 8
//thread-0 : 9
//thread-1 : 10
题目二
编写一个程序，开启 3 个线程，
这三个线程的分别为 A、B、C，每个线程打印对应的“A”、“B”、“C” 100000 遍，
要求输出的结果必须按顺序显示。如：ABCABCABC……
前4种统一使用一个全局变量state进行条件控制：
（1）state初始化为1，
如果state为1执行A线程，A线程修改state为2执行B线程；
如果state为2执行B线程，B线程修改state为3企图执行C线程；
如果state为3执行C线程，C线程修改state为1，企图执行A线程。
（2）或者state初始化为0，
如果state取余3=0，执行A线程；
如果state取余3=1,执行B线程；
如果stat取余3=2，执行C线程。
示例索引：
解法1：采用volatile修饰的全局变量state作为条件控制，用for循环加if条件判断的忙等模式。
解法2:采用原子类AtomicInteger来控制变量state
解法3：采用ReentrantLock锁住整段代码
解法4：采用ReentrantLock，三个Condition进行await和signal操作
解法5：使用信号量机制，完全不用state变量进行条件控制
解法一
/**
* 解法1：采用volatile修饰的全局变量state作为条件控制，用for循环加if条件判断的忙等模式。
*
* 问题：为什么共享变量要加volatile?加volatile就足够了吗？
* 分析：因为加volatile可以保证变量state的可见性，上一个线程对state的修改对下一个线程是可见的。
* 另外由于有if条件做判断，所以可以确保只有单一的线程修改变量state的值，这里用volatile就足够了。
*/
public class ABC1 {
private static int n = 10 * 10000;// 控制线程执行次数
private volatile static int state = 0; //控制线程执行条件
static class ThreadA extends Thread {
public void run() {
for (int i = 0; i < n; ) {
if (state % 3 == 0) {
System.out.println("A,loopNum=" + i);
state++;
i++;
}
}
}
}
static class ThreadB extends Thread {
public void run() {
for (int i = 0; i < n; ) {
if (state % 3 == 1) {
System.out.println("B,loopNum=" + i);
state++;
i++;
}
}
}
}
static class ThreadC extends Thread {
public void run() {
for (int i = 0; i < n; ) {
if (state % 3 == 2) {
System.out.println("C,loopNum=" + i);
state++;
i++;
}
}
}
}
public static void main(String[] args) throws InterruptedException {
long startTime = System.currentTimeMillis();
new ThreadA().start();
new ThreadB().start();
ThreadC c = new ThreadC();
c.start();
c.join();
long endTime = System.currentTimeMillis();
System.out.println("n=" + n);
System.out.println("RunTime is " + (double) (endTime - startTime) / 1000 + "s");
}
}
//A,loopNum=0
//B,loopNum=0
//C,loopNum=0
//A,loopNum=1
//B,loopNum=1
//C,loopNum=1
//A,loopNum=2
//B,loopNum=2
//C,loopNum=2
//...
//A,loopNum=99999
//B,loopNum=99999
//C,loopNum=99999
//RunTime is 5.764s
返回索引
解法二
import java.util.concurrent.atomic.AtomicInteger;
/**
* 解法2:采用原子类AtomicInteger来控制变量state，其他不变
*/
public class ABC2 {
private static int n = 10 * 10000;// 控制线程执行次数
private static AtomicInteger state = new AtomicInteger(0); //控制线程执行条件
static class ThreadA extends Thread {
public void run() {
for (int i = 0; i < n; ) {
if (state.get() % 3 == 0) {
System.out.println("A,loopNum=" + i);
state.getAndIncrement();
i++;
}
}
}
}
static class ThreadB extends Thread {
public void run() {
for (int i = 0; i < n; ) {
if (state.get() % 3 == 1) {
System.out.println("B,loopNum=" + i);
state.getAndIncrement();
i++;
}
}
}
}
static class ThreadC extends Thread {
public void run() {
for (int i = 0; i < n; ) {
if (state.get() % 3 == 2) {
System.out.println("C,loopNum=" + i);
state.getAndIncrement();
i++;
}
}
}
}
public static void main(String[] args) throws InterruptedException {
long startTime = System.currentTimeMillis();
new ThreadA().start();
new ThreadB().start();
ThreadC c = new ThreadC();
c.start();
c.join();
long endTime = System.currentTimeMillis();
System.out.println("RunTime is " + (double) (endTime - startTime) / 1000 + "s");
}
}
//A,loopNum=0
//B,loopNum=0
//C,loopNum=0
//A,loopNum=1
//B,loopNum=1
//C,loopNum=1
//A,loopNum=2
//B,loopNum=2
//C,loopNum=2
//...
//A,loopNum=99999
//B,loopNum=99999
//C,loopNum=99999
//RunTime is 4.901s
返回索引
解法三
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* 解法3：采用ReentrantLock锁住整段代码
*/
public class ABC3 {
private static int n = 10 * 10000;// 控制线程执行次数
private static int state = 0; // 控制线程执行条件
private static Lock lock = new ReentrantLock();
static class ThreadA extends Thread {
public void run() {
for (int i = 0; i < n; ) {
lock.lock();
if (state % 3 == 0) {
System.out.println("A,loopNum=" + i);
state++;
i++;
}
lock.unlock();
}
}
}
static class ThreadB extends Thread {
public void run() {
for (int i = 0; i < n; ) {
lock.lock();
if (state % 3 == 1) {
System.out.println("B,loopNum=" + i);
state++;
i++;
}
lock.unlock();
}
}
}
static class ThreadC extends Thread {
public void run() {
for (int i = 0; i < n; ) {
lock.lock();
if (state % 3 == 2) {
System.out.println("C,loopNum=" + i);
state++;
i++;
}
lock.unlock();
}
}
}
public static void main(String[] args) throws InterruptedException {
long startTime = System.currentTimeMillis();
new ThreadA().start();
new ThreadB().start();
ThreadC c = new ThreadC();
c.start();
c.join();
long endTime = System.currentTimeMillis();
System.out.println("RunTime is " + (double) (endTime - startTime) / 1000 + "s");
}
}
//A,loopNum=0
//B,loopNum=0
//C,loopNum=0
//A,loopNum=1
//B,loopNum=1
//C,loopNum=1
//A,loopNum=2
//B,loopNum=2
//C,loopNum=2
//...
//A,loopNum=99999
//B,loopNum=99999
//C,loopNum=99999
//RunTime is 5.45s
返回索引
解法四
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* 解法4：采用ReentrantLock，三个Condition进行await和signal操作
*/
public class ABC4 {
private static int n = 10 * 10000;// 控制线程执行次数
private static Lock lock = new ReentrantLock();
private static Condition A = lock.newCondition();
private static Condition B = lock.newCondition();
private static Condition C = lock.newCondition();
private static int state = 0;
private static class ThreadA extends Thread {
public void run() {
lock.lock();
try {
for (int i = 0; i < n; i++) {
if (state % 3 != 0)
A.await();
System.out.println("A,loopNum=" + i);
state++;
B.signal();
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
static class ThreadB extends Thread {
public void run() {
lock.lock();
try {
for (int i = 0; i < n; i++) {
if (state % 3 != 1)
B.await();
System.out.println("B,loopNum=" + i);
state++;
C.signal();
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
static class ThreadC extends Thread {
public void run() {
lock.lock();
try {
for (int i = 0; i < n; i++) {
if (state % 3 != 2)
C.await();
System.out.println("C,loopNum=" + i);
state++;
A.signal();
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
public static void main(String[] args) throws InterruptedException {
long startTime = System.currentTimeMillis();
new ThreadA().start();
new ThreadB().start();
ThreadC c = new ThreadC();
c.start();
c.join();
long endTime = System.currentTimeMillis();
System.out.println("RunTime is " + (double) (endTime - startTime) / 1000 + "s");
}
}
//A,loopNum=0
//B,loopNum=0
//C,loopNum=0
//A,loopNum=1
//B,loopNum=1
//C,loopNum=1
//A,loopNum=2
//B,loopNum=2
//C,loopNum=2
//...
//A,loopNum=99999
//B,loopNum=99999
//C,loopNum=99999
//RunTime is 3.784s
返回索引
解法五
import java.util.concurrent.Semaphore;
/**
* 解法5：使用信号量机制，完全不用state变量进行条件控制
*/
public class ABC5 {
private static int n = 10 * 10000;
private static Semaphore AB = new Semaphore(0);
private static Semaphore BC = new Semaphore(0);
private static Semaphore CA = new Semaphore(0);
static class ThreadA extends Thread {
@Override
public void run() {
try {
for (int i = 0; i < n; i++) {
CA.acquire();
System.out.println("A,loopNum=" + i);
AB.release();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
static class ThreadB extends Thread {
@Override
public void run() {
try {
for (int i = 0; i < n; i++) {
AB.acquire();
System.out.println("B,loopNum=" + i);
BC.release();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
static class ThreadC extends Thread {
@Override
public void run() {
try {
for (int i = 0; i < n; i++) {
BC.acquire();
System.out.println("C,loopNum=" + i);
CA.release();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) throws InterruptedException {
long startTime = System.currentTimeMillis();
CA.release(); //释放CA，让A线程先执行
new ThreadA().start();
new ThreadB().start();
ThreadC c = new ThreadC();
c.start();
c.join();
long endTime = System.currentTimeMillis();
System.out.println("RunTime is " + (double) (endTime - startTime) / 1000 + "s");
}
}
//A,loopNum=0
//B,loopNum=0
//C,loopNum=0
//A,loopNum=1
//B,loopNum=1
//C,loopNum=1
//A,loopNum=2
//B,loopNum=2
//C,loopNum=2
//...
//A,loopNum=99999
//B,loopNum=99999
//C,loopNum=99999
//RunTime is 3.672s
返回索引