题目描述
假设有这么一个类：
class ZeroEvenOdd {
public ZeroEvenOdd(int n) { … } // 构造函数
public void zero(printNumber) { … } // 仅打印出 0
public void even(printNumber) { … } // 仅打印出 偶数
public void odd(printNumber) { … } // 仅打印出 奇数
}
相同的一个 ZeroEvenOdd 类实例将会传递给三个不同的线程：
线程 A 将调用 zero()，它只输出 0 。
线程 B 将调用 even()，它只输出偶数。
线程 C 将调用 odd()，它只输出奇数。
每个线程都有一个 printNumber 方法来输出一个整数。请修改给出的代码以输出整数序列 010203040506… ，其中序列的长度必须为 2n。
示例 1：
输入：n = 2
输出：“0102”
说明：三条线程异步执行，其中一个调用 zero()，另一个线程调用 even()，最后一个线程调用odd()。正确的输出为 “0102”。
示例 2：
输入：n = 5
输出：“0102030405”
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/print-zero-even-odd
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
解决一： 使用死循环方式
- 思路：
使用一个state变量判断此时该打印什么数据， 如果某个线程死循环的判断此时打印的不是这个数子就使用Thread.yield()方法放弃此时的执行， 如果判断能执行就跳出循环， 执行下面的逻辑。再使用control变量， 判断此时是该输出奇数还是偶数
注意state要使用volatile修饰， 防止内存不可见问题
import java.util.function.IntConsumer;
public class ZeroEvenOdd {
private int n;
private volatile int state = 0;
private volatile boolean control = true;
public ZeroEvenOdd(int n) {
this.n = n;
}
// printNumber.accept(x) outputs "x", where x is an integer.
public void zero(IntConsumer printNumber) throws InterruptedException {
for (int i = 0; i < n; i++) {
while (state != 0) {
Thread.yield();
}
printNumber.accept(0);
if (control) {
state = 2;
} else {
state = 1;
}
}
}
public void even(IntConsumer printNumber) throws InterruptedException {
for (int i = 2; i <= n; i += 2) {
while (state != 2) {
Thread.yield();
}
printNumber.accept(i);
state = 0;
control = true;
}
}
public void odd(IntConsumer printNumber) throws InterruptedException {
for (int i = 1; i <= n; i += 2) {
while (state != 1) {
Thread.yield();
}
printNumber.accept(i);
state = 0;
control = false;
}
}
}
解法二：使用信号量机制
思路：
我们知道信号量有俩个关键的方法， 一个是acquire， 一个是release，这俩个方法是阻塞式的， 那我们实现三个信号量， 使用交替消费和释放实现0， 奇数， 偶数的打印。
何时让线程去停止执行关键在于for循环
import java.util.concurrent.Semaphore;
import java.util.function.IntConsumer;
/**
* 使用信号量机制可以完美解决
* 主要俩个方法， 一个是acquire还有一个好似release
* 最主要的还是要加一层for循环来终止线程
*/
class ZeroEvenOddBySem {
private int n;
private Semaphore zero = new Semaphore(1);
private Semaphore even = new Semaphore(0);
private Semaphore odd = new Semaphore(0);
public ZeroEvenOddBySem(int n) {
this.n = n;
}
// printNumber.accept(x) outputs "x", where x is an integer.
public void zero(IntConsumer printNumber) throws InterruptedException {
for (int i = 0; i < n; i++) {
zero.acquire();
printNumber.accept(0);
if (i % 2 == 0) {
odd.release();
} else {
even.release();
}
}
}
public void even(IntConsumer printNumber) throws InterruptedException {
for (int i = 2; i <= n; i += 2) {
even.acquire();
printNumber.accept(i);
zero.release();
}
}
public void odd(IntConsumer printNumber) throws InterruptedException {
for (int i = 1; i <= n; i += 2) {
odd.acquire();
printNumber.accept(i);
zero.release();
}
}
}
解法三：使用锁机制
思路：
锁机制在实现上逻辑比较复杂， 但是效率是高于上面那俩种解法的， 锁机制需要一个state变量来判断该那个线程去执行， 如果不该执行就进入阻塞等待唤醒， 如果该它执行就进入下面的代码逻辑。
奇数偶数的获取和线程的停止都是在for循环的关键， 这个要注意
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
import java.util.function.IntConsumer;
public class ZeroEvenOdd {
private int n;
private volatile int state = 0;
private ReentrantLock lock = new ReentrantLock();
private Condition zero = lock.newCondition();
private Condition even = lock.newCondition();
private Condition odd = lock.newCondition();
public ZeroEvenOdd(int n) {
this.n = n;
}
// printNumber.accept(x) outputs "x", where x is an integer.
public void zero(IntConsumer printNumber) throws InterruptedException {
for (int i = 0; i < n; i++) {
lock.lock();
while (state != 0) {
zero.await();
}
printNumber.accept(0);
if (i % 2 == 0) {
state = 1;
odd.signalAll();
} else {
state = 2;
even.signalAll();
}
lock.unlock();
}
}
public void even(IntConsumer printNumber) throws InterruptedException {
for (int i = 2; i <= n; i += 2) {
lock.lock();
while (state != 2) {
even.await();
}
state = 0;
printNumber.accept(i);
zero.signalAll();
lock.unlock();
}
}
public void odd(IntConsumer printNumber) throws InterruptedException {
for (int i = 1; i <= n; i+= 2) {
lock.lock();
while (state != 1) {
odd.await();
}
state = 0;
printNumber.accept(i);
zero.signalAll();
lock.unlock();
}
}
}