重庆分公司
重庆分公司，新征程启航
为企业提供网站建设、域名注册、服务器等服务
leetcode中怎么利用多线程实现按序打印
这篇文章给大家介绍leetcode中怎么利用多线程实现按序打印，内容非常详细，感兴趣的小伙伴们可以参考借鉴，希望对大家能有所帮助。
专注于为中小企业提供成都网站制作、网站建设服务,电脑端+手机端+微信端的三站合一,更高效的管理,为中小企业利川免费做网站提供优质的服务。我们立足成都，凝聚了一批互联网行业人才，有力地推动了近1000家企业的稳健成长，帮助中小企业通过网站建设实现规模扩充和转变。
我们提供了一个类：
public class Foo {
public void first() { print("first"); }
public void second() { print("second"); }
public void third() { print("third"); }
}
三个不同的线程 A、B、C 将会共用一个 Foo 实例。一个将会调用 first() 方法
一个将会调用 second() 方法
还有一个将会调用 third() 方法
请设计修改程序，以确保 second() 方法在 first() 方法之后被执行，third() 方法在 second() 方法之后被执行。
示例 1:
输入: [1,2,3]
输出: "firstsecondthird"
解释:
有三个线程会被异步启动。
输入 [1,2,3] 表示线程 A 将会调用 first() 方法，线程 B 将会调用 second() 方法，线程 C 将会调用 third() 方法。
正确的输出是 "firstsecondthird"。
示例 2:输入: [1,3,2]
输出: "firstsecondthird"
解释:
输入 [1,3,2] 表示线程 A 将会调用 first() 方法，线程 B 将会调用 third() 方法，线程 C 将会调用 second() 方法。
正确的输出是 "firstsecondthird"。
提示：
尽管输入中的数字似乎暗示了顺序，但是我们并不保证线程在操作系统中的调度顺序。
你看到的输入格式主要是为了确保测试的全面性。
实现方案1-锁
package com.lau.multithread.sortprint;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* 按序打印-实现方案1-锁
*
我们提供了一个类：
public class Foo {
public void first() { print("first"); }
public void second() { print("second"); }
public void third() { print("third"); }
}
三个不同的线程 A、B、C 将会共用一个 Foo 实例。
一个将会调用 first() 方法
一个将会调用 second() 方法
还有一个将会调用 third() 方法
请设计修改程序，以确保 second() 方法在 first() 方法之后被执行，third() 方法在 second() 方法之后被执行。
*
*
*/
class Foo {
private final Lock lock = new ReentrantLock();
final Condition firstCondition = lock.newCondition();
final Condition secondCondition = lock.newCondition();
final Condition thirdCondition = lock.newCondition();
private volatile int flag = 0;
public void first() {
try {
lock.lock();
while(this.flag != 0) {
firstCondition.await();
}
print("first");
flag = 1;
secondCondition.signal();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void second() {
try {
lock.lock();
while(this.flag != 1) {
secondCondition.await();
}
print("second");
flag = 2;
thirdCondition.signal();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void third() {
try {
lock.lock();
while(this.flag != 2) {
thirdCondition.await();
}
print("third");
flag = 0;
firstCondition.signal();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
private void print(String target) {
System.out.print(target);
}
}
public class PrintInOrderDemo {
public static void main(String[] args) {
ExecutorService threadPool = Executors.newFixedThreadPool(3);
Foo foo = new Foo();
Map map = new HashMap() {
{
put(1, () -> foo.first());
put(2, () -> foo.second());
put(3, () -> foo.third());
}
};
for(int i = 0; i < args.length; i++) {
threadPool.submit(map.get(Integer.valueOf(args[i])));
}
threadPool.shutdown();
}
} 实现方案2-传统方式
package com.lau.multithread.sortprint;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* 按序打印-实现方案2-传统方式
*
我们提供了一个类：
public class Foo {
public void first() { print("first"); }
public void second() { print("second"); }
public void third() { print("third"); }
}
三个不同的线程 A、B、C 将会共用一个 Foo 实例。
一个将会调用 first() 方法
一个将会调用 second() 方法
还有一个将会调用 third() 方法
请设计修改程序，以确保 second() 方法在 first() 方法之后被执行，third() 方法在 second() 方法之后被执行。
*
*
*/
class Foo2 {
private volatile int flag = 0;
public synchronized void first() {
try {
while(this.flag != 0) {
this.wait();
}
print("first");
flag = 1;
this.notifyAll();
} catch (Exception e) {
e.printStackTrace();
}
}
public synchronized void second() {
try {
while(this.flag != 1) {
this.wait();
}
print("second");
flag = 2;
this.notifyAll();
} catch (Exception e) {
e.printStackTrace();
}
}
public synchronized void third() {
try {
while(this.flag != 2) {
this.wait();
}
print("third");
flag = 0;
this.notifyAll();
} catch (Exception e) {
e.printStackTrace();
}
}
private void print(String target) {
System.out.print(target);
}
}
public class PrintInOrderDemo2 {
public static void main(String[] args) {
ExecutorService threadPool = Executors.newFixedThreadPool(3);
Foo2 foo = new Foo2();
Map map = new HashMap() {
{
put(1, () -> foo.first());
put(2, () -> foo.second());
put(3, () -> foo.third());
}
};
for(int i = 0; i < args.length; i++) {
threadPool.submit(map.get(Integer.valueOf(args[i])));
}
threadPool.shutdown();
}
} 实现方案3-信号量
package com.lau.multithread.sortprint;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
/**
* 按序打印-实现方案3-信号量
*
我们提供了一个类：
public class Foo {
public void first() { print("first"); }
public void second() { print("second"); }
public void third() { print("third"); }
}
三个不同的线程 A、B、C 将会共用一个 Foo 实例。
一个将会调用 first() 方法
一个将会调用 second() 方法
还有一个将会调用 third() 方法
请设计修改程序，以确保 second() 方法在 first() 方法之后被执行，third() 方法在 second() 方法之后被执行。
*
*
*/
class Foo3 {
private final Semaphore firstSp = new Semaphore(1);
private final Semaphore secondSp = new Semaphore(0);
private final Semaphore thirdSp = new Semaphore(0);
public void first() {
try {
firstSp.acquire();
print("first");
} catch (Exception e) {
e.printStackTrace();
} finally {
secondSp.release();
}
}
public void second() {
try {
secondSp.acquire();
print("second");
} catch (Exception e) {
e.printStackTrace();
} finally {
thirdSp.release();
}
}
public void third() {
try {
thirdSp.acquire();
print("third");
} catch (Exception e) {
e.printStackTrace();
} finally {
firstSp.release();
}
}
private void print(String target) {
System.out.print(target);
}
}
public class PrintInOrderDemo3 {
public static void main(String[] args) {
ExecutorService threadPool = Executors.newFixedThreadPool(3);
Foo3 foo = new Foo3();
Map map = new HashMap() {
{
put(1, () -> foo.first());
put(2, () -> foo.second());
put(3, () -> foo.third());
}
};
for(int i = 0; i < args.length; i++) {
threadPool.submit(map.get(Integer.valueOf(args[i])));
}
threadPool.shutdown();
}
} 打印设置：
输出：
firstsecondthird
关于leetcode中怎么利用多线程实现按序打印就分享到这里了，希望以上内容可以对大家有一定的帮助，可以学到更多知识。如果觉得文章不错，可以把它分享出去让更多的人看到。
标题名称：leetcode中怎么利用多线程实现按序打印
浏览路径：http://cqcxhl.com/article/jodcci.html