Java多个线程顺序循环执行的几种实现方式
文章目录
- ReentrantLock+Condition方式实现
- Synchronized+wait/notifyAll方式实现
- 两者对比
ReentrantLock+Condition方式实现
public class ReentrantLock_Impl {
private static final String FLAG_THREAD_1 = "ReentrantLock_Thread1";
private static final String FLAG_THREAD_2 = "ReentrantLock_Thread2";
private static final String FLAG_THREAD_3 = "ReentrantLock_Thread3";
public static void main(String[] args) throws InterruptedException {
//ReentrantLock构造方法传入true为公平锁 false为非公平锁
ReentrantLock lock = new ReentrantLock(true);
Condition condition1 = lock.newCondition();
Condition condition2 = lock.newCondition();
Condition condition3 = lock.newCondition();
FairRunnable runnable = new FairRunnable(lock, condition1, condition2, condition3);
new Thread(runnable, FLAG_THREAD_1).start();
new Thread(runnable, FLAG_THREAD_2).start();
new Thread(runnable, FLAG_THREAD_3).start();
}
static class FairRunnable implements Runnable {
private ReentrantLock lock;
private Condition condition1;
private Condition condition2;
private Condition condition3;
public FairRunnable(ReentrantLock lock, Condition condition1, Condition condition2, Condition condition3) {
this.lock = lock;
this.condition1 = condition1;
this.condition2 = condition2;
this.condition3 = condition3;
}
@Override
public void run() {
while (true) {
try {
lock.lock();
System.out.println(Thread.currentThread().getName() + "开始执行");
Thread.sleep(1000);
switch (Thread.currentThread().getName()) {
case FLAG_THREAD_1:
//唤醒线程2 自身线程挂起阻塞
condition2.signal();
condition1.await();
break;
case FLAG_THREAD_2:
//唤醒线程3 自身线程挂起阻塞
condition3.signal();
condition2.await();
break;
case FLAG_THREAD_3:
//唤醒线程1 自身线程挂起阻塞
condition1.signal();
condition3.await();
break;
}
} catch (Exception e) {
e.printStackTrace();
return;
} finally {
lock.unlock();
}
}
}
}
}
执行结果：
ReentrantLock_Thread1开始执行
ReentrantLock_Thread2开始执行
ReentrantLock_Thread3开始执行
ReentrantLock_Thread1开始执行
ReentrantLock_Thread2开始执行
ReentrantLock_Thread3开始执行
......
Synchronized+wait/notifyAll方式实现
public class Synchronized_Impl {
private static final String FLAG_THREAD_1 = "Synchronized_Thread1";
private static final String FLAG_THREAD_2 = "Synchronized_Thread2";
private static final String FLAG_THREAD_3 = "Synchronized_Thread3";
public static void main(String[] args) {
FairRunnable runnable = new FairRunnable();
new Thread(runnable, FLAG_THREAD_1).start();
new Thread(runnable, FLAG_THREAD_2).start();
new Thread(runnable, FLAG_THREAD_3).start();
}
static class FairRunnable implements Runnable {
private volatile static int flag = 1;
private final Object object = new Object();
@Override
public void run() {
while (true) {
synchronized (object) {
//如果当前情况是：线程1&flag!=1、线程2&flag!=2、线程3&flag!=3 那当前线程通过object.wait挂起
switch (Thread.currentThread().getName()) {
case FLAG_THREAD_1:
while (flag != 1) {
try {
object.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
break;
case FLAG_THREAD_2:
while (flag != 2) {
try {
object.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
break;
case FLAG_THREAD_3:
while (flag != 3) {
try {
object.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
break;
}
//线程任务开始执行
System.out.println(Thread.currentThread().getName() + "开始执行");
try {
//模拟线程任务执行
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
break;
}
switch (Thread.currentThread().getName()) {
case FLAG_THREAD_1:
//接下来该去执行线程2
flag = 2;
break;
case FLAG_THREAD_2:
//接下来该去执行线程3
flag = 3;
break;
case FLAG_THREAD_3:
//接下来该去执行线程1
flag = 1;
break;
}
//唤醒所有线程
object.notifyAll();
}
}
}
}
}
执行结果：
Synchronized_Thread1开始执行
Synchronized_Thread2开始执行
Synchronized_Thread3开始执行
Synchronized_Thread1开始执行
Synchronized_Thread2开始执行
Synchronized_Thread3开始执行
......
两者对比
使用ReentrantLock+Condition可以更准确的控制唤醒哪一个线程；而Synchronized+wait/notifyAll的方式可能会出现获取锁的线程并不是目标线程，此时获取锁的线程会重新挂起，直到获取锁的线程即是目标线程为止。比如上面代码中：线程1执行完后调用notifyAll(), 此时线程2、线程3都会被唤醒并尝试获取锁，如果此时线程3获得锁，那么线程2还要继续等待，线程3执行时发现并不是要执行的目标线程，那么线程3会调用wait()挂起，此时entrySet中只有线程2了，线程2也是要执行的目标线程，此时才会去执行线程2，整个过程多了一次线程3的获取与释放锁，原因就是wait/notifyAll并不能像ReentrantLock+Condition一样能精确地唤醒某个线程。