这期内容当中小编将会给大家带来有关leetcode中怎么利用多线程打印零与奇偶数，文章内容丰富且以专业的角度为大家分析和叙述，阅读完这篇文章希望大家可以有所收获。
假设有这么一个类：
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"
package com.lau.multithread.printoddeven;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Consumer;
/**
*
* 打印零与奇偶数——实现方案——传统方式
假设有这么一个类：
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"
*
*
*/
class ZeroEvenOdd {
private volatile int flag = 0;
private volatile int n;
private AtomicInteger i;
//构造函数
public ZeroEvenOdd(int n) {
this.n = n;
this.i = new AtomicInteger(1);
}
//仅打印出 0
public void zero(Runnable printNumber) {
for(int k = 0; k < n; k++) {
synchronized (this) {
try {
while(0 != this.flag) {
this.wait();
}
printNumber.run();
flag = 1;
}
catch (InterruptedException e) {
e.printStackTrace();
}
finally {
this.notifyAll();
}
}
}
}
//仅打印出 偶数
public void even(Consumer<Integer> printNumber) {
for(int k = 0; k < n; k++) {
synchronized (this) {
try {
while(1 != this.flag) {
this.wait();
}
if(this.i.get() % 2 == 0) {
printNumber.accept(this.i.get());
this.i.incrementAndGet();
flag = 0;
}
else {
flag = 2;
}
this.notifyAll();
}
catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
//仅打印出 奇数
public void odd(Consumer<Integer> printNumber) {
for(int k = 0; k < n; k++) {
synchronized (this) {
try {
while(2 != this.flag) {
this.wait();
}
printNumber.accept(this.i.get());
this.i.incrementAndGet();
flag = 0;
this.notifyAll();
}
catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
public class PrintOddEvenDemo {
public static void main(String[] args) {
ExecutorService threadPool = Executors.newFixedThreadPool(3);
ZeroEvenOdd zeroEvenOdd = new ZeroEvenOdd(9);
threadPool.submit(() -> zeroEvenOdd.zero(() -> System.out.print("0")));
threadPool.submit(() -> zeroEvenOdd.even(t -> System.out.print(String.valueOf(t))));
threadPool.submit(() -> zeroEvenOdd.odd(t -> System.out.print(String.valueOf(t))));
threadPool.shutdown();
}
}package com.lau.multithread.printoddeven;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.function.Consumer;
/**
*
* 打印零与奇偶数——实现方案——锁方式
假设有这么一个类：
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"
*
*
*/
class ZeroEvenOdd2 {
private final Lock lock = new ReentrantLock();
final Condition zeroCd = lock.newCondition();
final Condition evenCd = lock.newCondition();
final Condition oddCd = lock.newCondition();
private volatile int flag = 0;
private volatile int n;
private AtomicInteger i;
//构造函数
public ZeroEvenOdd2(int n) {
this.n = n;
this.i = new AtomicInteger(1);
}
//仅打印出 0
public void zero(Runnable printNumber) {
for(int k = 0; k < n; k++) {
try {
lock.lock();
while(0 != this.flag) {
zeroCd.await();
}
printNumber.run();
flag = 1;
evenCd.signal();
}
catch (InterruptedException e) {
e.printStackTrace();
}
finally {
lock.unlock();
}
}
}
//仅打印出 偶数
public void even(Consumer<Integer> printNumber) {
for(int k = 0; k < n; k++) {
try {
lock.lock();
while(1 != this.flag) {
evenCd.await();
}
if(this.i.get() % 2 == 0) {
printNumber.accept(this.i.get());
this.i.incrementAndGet();
flag = 0;
zeroCd.signal();
}
else {
flag = 2;
oddCd.signal();
}
}
catch (InterruptedException e) {
e.printStackTrace();
}
finally {
lock.unlock();
}
}
}
//仅打印出 奇数
public void odd(Consumer<Integer> printNumber) {
for(int k = 0; k < n; k++) {
try {
lock.lock();
while(2 != this.flag) {
oddCd.await();
}
printNumber.accept(this.i.get());
this.i.incrementAndGet();
flag = 0;
zeroCd.signal();
}
catch (InterruptedException e) {
e.printStackTrace();
}
finally {
lock.unlock();
}
}
}
}
public class PrintOddEvenDemo2 {
public static void main(String[] args) {
ExecutorService threadPool = Executors.newFixedThreadPool(3);
ZeroEvenOdd2 zeroEvenOdd = new ZeroEvenOdd2(5);
threadPool.submit(() -> zeroEvenOdd.zero(() -> System.out.print("0")));
threadPool.submit(() -> zeroEvenOdd.even(t -> System.out.print(String.valueOf(t))));
threadPool.submit(() -> zeroEvenOdd.odd(t -> System.out.print(String.valueOf(t))));
threadPool.shutdown();
}
}package com.lau.multithread.printoddeven;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.function.Consumer;
/**
*
* 打印零与奇偶数——实现方案——信号量
假设有这么一个类：
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"
*
*
*/
class ZeroEvenOdd3 {
private final Semaphore zeroSp = new Semaphore(1);
private final Semaphore evenSp = new Semaphore(0);
private final Semaphore oddSp = new Semaphore(0);
private volatile int n;
private AtomicInteger i;
//构造函数
public ZeroEvenOdd3(int n) {
this.n = n;
this.i = new AtomicInteger(1);
}
//仅打印出 0
public void zero(Runnable printNumber) {
for(int k = 0; k < n; k++) {
try {
zeroSp.acquire();
printNumber.run();
}
catch (InterruptedException e) {
e.printStackTrace();
}
finally {
evenSp.release();
}
}
}
//仅打印出 偶数
public void even(Consumer<Integer> printNumber) {
for(int k = 0; k < n; k++) {
try {
evenSp.acquire();
if(this.i.get() % 2 == 0) {
printNumber.accept(this.i.get());
this.i.incrementAndGet();
zeroSp.release();
}
else {
oddSp.release();
}
}
catch (InterruptedException e) {
e.printStackTrace();
}
}
}
//仅打印出 奇数
public void odd(Consumer<Integer> printNumber) {
for(int k = 0; k < n; k++) {
try {
oddSp.acquire();
printNumber.accept(this.i.get());
this.i.incrementAndGet();
}
catch (InterruptedException e) {
e.printStackTrace();
}
finally {
zeroSp.release();
}
}
}
}
public class PrintOddEvenDemo3 {
public static void main(String[] args) {
ExecutorService threadPool = Executors.newFixedThreadPool(3);
ZeroEvenOdd3 zeroEvenOdd = new ZeroEvenOdd3(10);
threadPool.submit(() -> zeroEvenOdd.zero(() -> System.out.print("0")));
threadPool.submit(() -> zeroEvenOdd.even(t -> System.out.print(String.valueOf(t))));
threadPool.submit(() -> zeroEvenOdd.odd(t -> System.out.print(String.valueOf(t))));
threadPool.shutdown();
}
}输出：
010203040506070809
上述就是小编为大家分享的leetcode中怎么利用多线程打印零与奇偶数了，如果刚好有类似的疑惑，不妨参照上述分析进行理解。如果想知道更多相关知识，欢迎关注亿速云行业资讯频道。
免责声明：本站发布的内容（图片、视频和文字）以原创、转载和分享为主，文章观点不代表本网站立场，如果涉及侵权请联系站长邮箱：is@yisu.com进行举报，并提供相关证据，一经查实，将立刻删除涉嫌侵权内容。
