给你一个类:
public class Foo {
public void first() { print("first"); }
public void second() { print("second"); }
public void third() { print("third"); }
}
三个不同的线程 A、B、C 将会共用一个 Foo 实例。
- 线程 A 将会调用 first() 方法
- 线程 B 将会调用 second() 方法
- 线程 C 将会调用 third() 方法
- 请设计修改程序,以确保 second() 方法在 first() 方法之后被执行,third() 方法在 second() 方法之后被执行。
方法1 — 控制变量
class Foo {
int order = 1;
public Foo() {
}
public void first(Runnable printFirst) throws InterruptedException {
printFirst.run();
order = 2;
}
public void second(Runnable printSecond) throws InterruptedException {
while (order != 2) {}
printSecond.run();
order = 3;
}
public void third(Runnable printThird) throws InterruptedException {
while (order != 3) {}
printThird.run();
}
}
- 上面方法会超时
- 原因是没有实现可见性, 也就是线程没有立即得到order更新后的值, 所以一直卡在while循环里, 导致超时
- 比如线程1将order修改为2之后, 线程2没有得到这个更新, 导致一致卡在自己的while循环中
- 关于可见性: 线程在执行的时候会将主内存中的变量拷贝一份到工作内存中,之后线程的运行只与工作内存打交道
使用volatile关键字优化
- volatile关键字可以保证可见性, 也就是对变量的更新可以立即被其他线程所捕获
class Foo {
volatile int order = 1;
public Foo() {
}
public void first(Runnable printFirst) throws InterruptedException {
printFirst.run();
order = 2;
}
public void second(Runnable printSecond) throws InterruptedException {
while (order != 2) {}
printSecond.run();
order = 3;
}
public void third(Runnable printThird) throws InterruptedException {
while (order != 3) {}
printThird.run();
}
}
- 以上实现方法还有缺点, 就是当一个线程执行时, 其他线程会不断的执行while循环, 消耗CPU的资源
- 可以通过synchronized + wait + notifyAll的方式解决
方法2 — synchronized + wait + notifyAll
- 使用wait可以让目前还不能允许的线程进入等待阻塞状态, 直到正在允许的线程完成任务之后调用notifyAll唤醒.
- 当其他线程被唤醒后, 会竞争锁
- 当一个线程拿到锁之后, 通过flag检查是否该自己运行, 如果不该自己运行则又进入等待阻塞状态, 并且释放锁
public class Foo {
private int flag = 0;
//声明一个objetc作为锁
private Object lock = new Object();
public Foo() {
}
public void first(Runnable printFirst) throws InterruptedException {
synchronized (lock){
while( flag != 0){
//还没有轮到自己运行, 进入阻塞状态.
lock.wait();
}
printFirst.run();
flag = 1;
//唤醒其他在阻塞状态的线程
lock.notifyAll();
}
}
public void second(Runnable printSecond) throws InterruptedException {
synchronized (lock){
while (flag != 1){
lock.wait();
}
printSecond.run();
flag = 2;
lock.notifyAll();
}
}
public void third(Runnable printThird) throws InterruptedException {
synchronized (lock){
while (flag != 2){
lock.wait();
}
printThird.run();
flag = 0;
lock.notifyAll();
}
}
}
方法3 — 信号量
class Foo {
//控制第一个和第二个线程的顺序,初始信号量为0
private final Semaphore first_to_second =new Semaphore(0);
//控制第二个和第三个线程的顺序, 初始信号量为0
private final Semaphore second_to_third =new Semaphore(0);
public Foo() {
}
public void first(Runnable printFirst) throws InterruptedException {
printFirst.run();
first_to_second.release();//增加信号量, first_to_second的信号量变为0, 将线程2唤起
}
public void second(Runnable printSecond) throws InterruptedException {
//尝试获取信号量, first_to_second 初始为0, count--, 信号量变为-1, 线程2被放入blocking queue
first_to_second.acquire();
printSecond.run();
//增加信号量, second_to_third的信号量变为0, 将线程3唤起
second_to_third.release();
}
public void third(Runnable printThird) throws InterruptedException {
//尝试获取信号量, second_to_third 初始为0, count--, 信号量变为-1, 线程3被放入blocking queue
second_to_third.acquire();
printThird.run();
}
}
//pseudo code
struct {
int counter;//表示目前的资源数量
queue q;//用于存放等待中的线程
} sem_t
//v operation: release
signal(sem_t *s) {
s.counter++;
//counter小于等于0则说明有线程在排队等待消费资源,所以需要队列中的资源移出,然后唤醒线程
if (s.counter <= 0) {
remove(s.q, p);
wakeup(q);
}
}
//p operation: wait
wait(sem_t *s) {
s.counter--;
//counter为负说明目前没有资源可供消费,则需要将目前进程放进等待队列, 然后block掉
if (s.counter < 0) {
add this thread to s.q;
block();
}
}