前言
有很多中写法,希望可以慢慢都写出来。
1、线程共享类对象:依靠AtomicInteger是线程安全的
将 AtomicInteger currentCount 作为线程共享。
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
/**
* 三个线程按次序轮流打印a,b,c AtomicInteger 实现
*
*/
public class AtomicIntegerThread implements Runnable {
private AtomicInteger currentCount = new AtomicInteger(0);
private static final Integer MAX_COUNT = 6;
private static String[] chars = {"a", "b", "c"};
private String name;
public AtomicIntegerThread(String name,AtomicInteger currentCount) {
this.name = name;
this.currentCount = currentCount;
}
@Override
public void run() {
while (currentCount.get() < MAX_COUNT) {
if (this.name.equals(chars[currentCount.get() % 3])) {
printAndPlusOne(this.name);
}
}
}
public void printAndPlusOne(String content) {
System.out.print(content);
currentCount.getAndIncrement();
}
public static void main(String[] args) {
AtomicInteger currentCount = new AtomicInteger(0);
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(3, 3, 20, TimeUnit.MINUTES, new LinkedBlockingQueue<Runnable>());
threadPoolExecutor.execute(new AtomicIntegerThread("a",currentCount));
threadPoolExecutor.execute(new AtomicIntegerThread("b",currentCount));
threadPoolExecutor.execute(new AtomicIntegerThread("c",currentCount));
threadPoolExecutor.shutdown();
}
}
这里一定要注意有一个坑,如果线程池核心线程数少于3个,1个或者2个,上述代码会有问题,因为线程池的队列是无界队列,多余核心线程数的任务会被放到队列中,这样循环打印的时候,有一些线程不是在运行中的,是在队列里的,运行中的线程会被阻塞,导致相互等待,死锁问题出现。所以线程池的核心线程数必须等于大于3个,这样保证有3个线程一直在运行。
2、volatile静态变量控制
还有一种就是将某个变量设置为静态,这样线程本身也共享该变量,则可以对其操作。但要注意给这个静态变量加上volatile字段,这个字段可以帮助多线程中的可见性。代码如下:
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
/**
* 三个线程按次序轮流打印a,b,c
*
*/
public class StaticVarThread implements Runnable {
private static volatile Integer currentCount = 0;
private static final Integer MAX_COUNT = 6;
private static String[] chars = {"a", "b", "c"};
private String name;
public StaticVarThread(String name) {
this.name = name;
}
@Override
public void run() {
while (currentCount < MAX_COUNT) {
try {
while (this.name.equals(chars[currentCount % 3]) && currentCount < MAX_COUNT) {
printAndPlusOne(this.name);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
}
}
}
public void printAndPlusOne(String name) {
System.out.println(name + "\t" + currentCount);
currentCount++;
}
public static void main(String[] args) {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(3, 3, 20, TimeUnit.MINUTES, new LinkedBlockingQueue<Runnable>());
threadPoolExecutor.execute(new StaticVarThread("a"));
threadPoolExecutor.execute(new StaticVarThread("b"));
threadPoolExecutor.execute(new StaticVarThread("c"));
threadPoolExecutor.shutdown();
}
}
3、synchronized对象加锁
利用一个计数来除线程个数得到余数从而控制线程输出,并且利用synchronized、一个Object的wait()和notify()方法来对线程的阻塞和唤醒,这里的技巧可以看看。
- wait()
阻塞当前线程,等待被释放,继续执行当前线程 - notify()
唤醒监视该对象的第一个线程,notifyAll()唤醒监视该对象的所有线程。
代码:
static volatile int state; // 线程共有,判断所有的打印状态
static final Object t = new Object(); // 线程共有,加锁对象
/**
* 改装了一下
*/
@Test
public void mainSix() {
state = 0;
// 需要循环的次数
int n = 3;
int num = 2;
new MyThread("A", 0, n, num).start();
new MyThread("B", 1, n, num).start();
}
class MyThread extends Thread {
String name;
int which; // 标示符:0:打印A;1:打印B;2:打印C
int n; // 0:打印次数
int num; // 循环周期
public MyThread(String name,int which,int n,int num) {
this.name = name;
this.which = which;
this.n = n;
this.num = num;
}
@Override
public void run() {
for (int i = 0; i < n; i++) {
synchronized (t) {
while (state % num != which) {
try {
t.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.print(name); // 执行到这里,表明满足条件,打印
state++;
t.notify(); // 调用notifyAll方法
}
}
}
}
4、condition 与lock的结合
synchronized关键字与wait()和notify/notifyAll()方法相结合可以实现等待/通知机制,ReentrantLock类当然也可以实现,但是需要借助于Condition接口与lock 对象的newCondition() 方法,condition 是lock对象所创建的,在Condition中,用await()替换wait(),用signal()替换notify(),用signalAll()替换notifyAll(),传统线程的通信方式,Condition都可以实现,其突出的优点有:
- Condition能够支持不响应中断,而通过使用Object方式不支持;
- Condition能够支持多个等待队列(new 多个Condition对象),而Object方式只能支持一个;
- Condition能够支持超时时间的设置,而Object不支持
- 调用Condition的await()和signal()方法,都必须在lock保护之内,就是说必须在lock.lock()和lock.unlock之间才可以使用
使用场景:多个condition的唤醒机制,比如多个生产者同时生产,多个消费者同时消费,需要两个condition来唤醒,或者是有先后顺序执行的线程,比如顺序打印ABC。
Condition是基于AQS同步机制的同步方法。 AbstractQueuedSynchronizer(AQS)。
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class ConditionTwo extends Thread {
private Lock lock;
private int count;
private String str;
private int flag;
Condition A;
Condition B;
public ConditionTwo(String str, int flag, int count, Lock lock, Condition A, Condition B) {
this.str = str;
this.flag = flag;
this.A = A;
this.B = B;
this.count = count;
this.lock = lock;
}
@Override
public void run() {
try {
lock.lock();
while (count<2) {
System.out.println(" str = " + str+" count =" +count);
count++;
// 唤醒 B 线程
B.signal();
// 暂停自己进程
A.await();
}
} catch (Exception e) {
e.printStackTrace();
} finally {
B.signal();
lock.unlock();
}
}
public static void main(String[] args) throws InterruptedException {
Lock lock = new ReentrantLock();
int count = 0;
Condition A = lock.newCondition();
Condition B = lock.newCondition();
Condition C = lock.newCondition();
new ConditionTwo("a", 0,count,lock, A, B).start();
// 必须要加 这个限制,不然可能不是a 先执行
Thread.sleep(500);
new ConditionTwo("b", 1,count,lock, B, C).start();
new ConditionTwo("c", 2,count,lock, C, A).start();
}
}