最近面试遇到的一道题,需要三个线程交替打印0-100,当时对多线程并不是很熟悉因此没怎么写出来,网上搜了之后得到现
synchronized + wait/notifyAll
实现思路:判断当前打印数字和线程数的取余,不等于当前线程则处于等待状态。循环结束唤醒所有等待线程。
public class PrintExample {
//创建一个公共锁对象
private static final Object Lock = new Object();
//执行线程数
private static final int THREAD_COUNT = 3;
//打印数字的起始点
private static volatile int START = 0;
//打印数字的结束点
private static final int END = 100;
private static class Print implements Runnable{
private final int index;
public Print(int index){
this.index = index;
}
@Override
public void run() {
while(START<END){
synchronized (Lock){
//START和线程数进行取余,如果不等于当前线程的则等待
while(START % THREAD_COUNT != index){
try{
Lock.wait();
}catch (Exception e){
e.printStackTrace();
}
}
//否则进行输出
if(START<=END){
System.out.println("Thread" + (index+1) + ",打印结果:" + START);
}
START++;
//唤醒等待线程
Lock.notifyAll();
}
}
}
public static void main(String[] args) {
for(int i = 0; i < THREAD_COUNT; i++){
new Thread(new Print(i)).start();
}
}
}
}
文章来源地址https://www.toymoban.com/news/detail-686142.html
ReetrantLock + await/signalAll
实现思路:实现方式和synchronized + wait/notifyAll儿乎完全一样。我们只需要4步:
1.synchronized 替换为ReentrantLock
2.根据锁对象创建一个Condition对象
3.wait替换成await
4.notifyAll 替换为 signalAll
public class PrintExample {
//创建一个公共锁对象
private static final ReentrantLock Lock = new ReentrantLock();
//根据锁对象创建一个Condition对象
private static final Condition CONDITION = Lock.newCondition();
//执行线程数
private static final int THREAD_COUNT = 3;
//打印数字的起始点
private static volatile int START = 0;
//打印数字的结束点
private static final int END = 100;
private static class Print implements Runnable{
private final int index;
public Print(int index){
this.index = index;
}
@Override
public void run() {
while(START<END){
Lock.lock();
try {
//START和线程数进行取余,如果不等于当前线程的则等待
while(START % THREAD_COUNT != index){
try{
CONDITION.await();
}catch (Exception e){
e.printStackTrace();
}
}
//否则进行输出
if(START<=END){
System.out.println("Thread" + (index+1) + ",打印结果:" + START);
}
START++;
//唤醒等待线程
CONDITION.signalAll();
}catch (Exception e){
e.printStackTrace();
}finally {
Lock.unlock();
}
}
}
public static void main(String[] args) {
for(int i = 0; i < THREAD_COUNT; i++){
new Thread(new Print(i)).start();
}
}
}
}
ReetrantLock + await/signal
因为Condition相对wait/notify方式,可以唤醒指定线程。那我们就完全不用每次都唤醒全部线程,仅需要唤醒下一次需要执行的线程就可以了。
相比较 ReentrantLock + await/signalAll 改进方法:
1.去除公共的Condition对象,替换为List<Condition> conditions;
2.调用"下一个线程的"Condition对象的signal方法唤醒下一个线程;
public class PrintExample {
//创建一个公共锁对象
private static final ReentrantLock Lock = new ReentrantLock();
//根据锁对象创建一个Condition对象
//private static final Condition CONDITION = Lock.newCondition();
//执行线程数
private static final int THREAD_COUNT = 3;
//打印数字的起始点
private static volatile int START = 0;
//打印数字的结束点
private static final int END = 100;
private static class Print implements Runnable{
private final int index;
private final List<Condition> conditions;
public Print(int index,List<Condition> conditions){
this.index = index;
this.conditions = conditions;
}
//只唤醒下一个线程
private void signalNext(){
int nextIndex = (index + 1) % THREAD_COUNT;
conditions.get(nextIndex).signal();
}
@Override
public void run() {
while(START<END){
Lock.lock();
try {
//START和线程数进行取余,如果不等于当前线程的则等待
while(START % THREAD_COUNT != index){
try{
conditions.get(index).await();
}catch (Exception e){
e.printStackTrace();
}
}
//否则进行输出
if(START<=END){
System.out.println("Thread" + (index+1) + ",打印结果:" + START);
}
START++;
//唤醒等待线程
signalNext();
}catch (Exception e){
e.printStackTrace();
}finally {
Lock.unlock();
}
}
}
public static void main(String[] args) {
List<Condition> conditionList = new ArrayList<>();
conditionList.add(Lock.newCondition());
conditionList.add(Lock.newCondition());
conditionList.add(Lock.newCondition());
for(int i = 0; i < THREAD_COUNT; i++){
new Thread(new Print(i,conditionList)).start();
}
}
}
}
此处使用 List<Condition> conditions让每个线程都拥有属于自己的condition,这样可以单独唤醒和等待。
Condition是什么
概念:
condition可以理解为条件队列。当一个线程在调用了其await方法以后,直到线程等待的某个条件为真的时候才会被唤醒。Condition必须要配合锁一起使用,因为对共享状态变量的访问发生在多线程环境下。一个Condition的实例必须与一个Lock绑定,因此Condition一般都是作为Lock的内部实现
方法:
Condition依赖于Lock接口
方法 | 解释 |
lock.newCondition() | 生成一个Condition |
await() | 对应Object的wait();使线程等待 |
signal() | 对应Object的notify();唤醒线程 |
注意:调用Condition的await()和signal()方法,都必须在lock.lock()和lock.unlock()之间使用
在生产者和消费者中Condition的执行方式:
- 当在线程Consumer中调用await方法后,线程Consumer将释放锁,并且将自己沉睡,等待唤醒。
- 这时等到线程Producer获取到锁后,开始执行任务,完毕后,调用Condition的signalall方法,唤醒线程Consumer,线程Consumer恢复执行。
以上说明Condition是一个多线程间协调通信的工具类,使得某个或某些线程一起等待某个条件(Condition),只有当该条件具备( signal 或者 signalAll方法被带调用)时 ,这些等待线程才会被唤醒,从而重新争夺锁文章来源:https://www.toymoban.com/news/detail-686142.html
到了这里,关于高频面试题:如何分别用三种姿势实现三个线程交替打印0到100的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!