LeetCode 1114：按序打印

已于 2022-04-05 18:37:07 修改
阅读量950 收藏
点赞数
分类专栏： LeetCode 文章标签： 线程交替打印
于 2022-04-05 18:18:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43161461/article/details/123973884
版权

LeetCode 1114：按序打印

题目描述

给你一个类：

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() 方法之后被执行。

解题思路

本文重点介绍Semaphore的两个变种解法，第一种是常规接发，相当于3个线程，有一个充当主线程做if else判断，其他执行线程满足if条件执行acquire时，因为Semaphore变量为0所以会停止等待，等待类主线程执行release后，完成相应Semaphore的+1操作，对应线程可继续执行打印输出。最后不要忘记对在支路线程中对主线程的Semaphore进行release的+1操作，便于后续其他线程执行相似操作。
Semaphore的法二则更加简洁巧妙，原理也是按顺序一个线程先执行acquire，Semaphore为0时等待停止，后续对下一个Semaphore进行release，相当于通知下一个等待中的线程可以继续执行，以此来控制线程的打印顺序。

代码实现

Synchronized

class Foo {
    private int i = 1;
    private int n = 3;


    public Foo() {
        
    }

    public void first(Runnable printFirst) throws InterruptedException {
        while(i <= n){
            synchronized(this){
                if(i <= n && i % 3 == 1){
                    printFirst.run();
                    i++;
                }
            }
        }
        
    }

    public void second(Runnable printSecond) throws InterruptedException {
        while(i <= n){
            synchronized(this){
                if(i <= n && i % 3 == 2){
                    printSecond.run();
                    i++;
                }
            }
        }
    }

    public void third(Runnable printThird) throws InterruptedException {
        while(i <= n){
            synchronized(this){
                if(i <= n && i % 3 == 0){
                    printThird.run();
                    i++;
                }
            }
        }
    }
}

ReentrantLock

class Foo {
    private int i = 1;
    private int n = 3;

    private Lock lock = new ReentrantLock();

    public Foo() {
        
    }

    public void first(Runnable printFirst) throws InterruptedException {
        while(i <= n){
            lock.lock();
            try{
                if(i <= n && i % 3 == 1){
                    printFirst.run();
                    i++;
                }
            }finally{
                lock.unlock();
            }
        }
        
    }

    public void second(Runnable printSecond) throws InterruptedException {
        while(i <= n){
            lock.lock();
            try{
                if(i <= n && i % 3 == 2){
                    printSecond.run();
                    i++;
                }
            }finally{
                lock.unlock();
            }
        }
    }

    public void third(Runnable printThird) throws InterruptedException {
        while(i <= n){
            lock.lock();
            try{
                if(i <= n && i % 3 == 0){
                    printThird.run();
                    i++;
                }
            }finally{
                lock.unlock();
            }
        }
    }
}

CyclicBarrier

class Foo {
    private int i = 1;
    private int n = 3;

    private CyclicBarrier cb = new CyclicBarrier(3);

    public Foo() {
        
    }

    public void first(Runnable printFirst) throws InterruptedException {
        
        for(int i = 1;i <= n ;i++){
            if(i<= n && i % 3 == 1){
                printFirst.run();
            }
            try{
                cb.await();
            }catch(BrokenBarrierException e){
                e.printStackTrace();
            }
        }
        
        
    }

    public void second(Runnable printSecond) throws InterruptedException {
        
        for(int i = 1;i <= n ;i++){
            if(i<= n && i % 3 == 2){
                printSecond.run();
            }
            try{
                cb.await();
            }catch(BrokenBarrierException e){
                e.printStackTrace();
            }
        }
        
    }

    public void third(Runnable printThird) throws InterruptedException {
    
        for(int i = 1;i <= n ;i++){
            if(i<= n && i % 3 == 0){
                printThird.run();
            }
            try{
                cb.await();
            }catch(BrokenBarrierException e){
                e.printStackTrace();
            }
        }
        
    }
}

Semaphore法一

class Foo {
    private int i = 1;
    private int n = 3;

    private Semaphore semaphore1 = new Semaphore(0);
    private Semaphore semaphore2 = new Semaphore(0);
    private Semaphore semaphore3 = new Semaphore(1);

    public Foo() {
        
    }

    public void first(Runnable printFirst) throws InterruptedException {
        while(i <= n){
            if(i<= n && i % 3 == 1){
                semaphore1.acquire();
                printFirst.run();
                i++;
                semaphore3.release();
            }
        }   
    }

    public void second(Runnable printSecond) throws InterruptedException {
        while(i <= n){
            if(i<= n && i % 3 == 2){
                semaphore2.acquire();
                printSecond.run();
                i++;
                semaphore3.release();
            }
        }   
    }

    public void third(Runnable printThird) throws InterruptedException {
        while(i <= n){
            semaphore3.acquire();
            if(i<= n && i % 3 == 0){
                printThird.run();
                i++;
                semaphore3.release();
            }else if(i<= n && i % 3 == 1){
                semaphore1.release();
            }else if(i<= n && i % 3 == 2){
                semaphore2.release();
            }
        }   
    }
}

Semaphore法二

class Foo {
    private int i = 1;
    private int n = 3;

    private Semaphore semaphore12 = new Semaphore(0);
    private Semaphore semaphore23 = new Semaphore(0);


    public Foo() {
        
    }

    public void first(Runnable printFirst) throws InterruptedException {
        printFirst.run();
        semaphore12.release();

    }

    public void second(Runnable printSecond) throws InterruptedException {
        semaphore12.acquire();
        printSecond.run();
        semaphore23.release();
    }

    public void third(Runnable printThird) throws InterruptedException {
       semaphore23.acquire();
       printThird.run();
    }
}

总结

本题来源于Leetcode中 归属于多线程类型题目。
同许多在算法道路上不断前行的人一样，不断练习，修炼自己！
如有博客中存在的疑问或者建议，可以在下方留言一起交流，感谢各位！

觉得本博客有用的客官，可以给个赞鼓励下！ 嘿嘿

香农派我最爱
关注
专栏目录
Leetcode 1114. 按序打印
我不是萧海哇的博客
05-18 187
给你一个类： 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() 方法 请设计.
【Python】【难度：简单】Leetcode 1114. 按序打印
thomashhs12的博客
06-19 381
我们提供了一个类： public class Foo { public void one() { print("one"); } public void two() { print("two"); } public void three() { print("three"); } } 三个不同的线程将会共用一个Foo实例。 线程 A 将会调用 one() 方法 线程 B 将会调用two() 方法 线程 C 将会调用 three() 方法 请设计修改程序，以确保 two() 方法在 on...
Leetcode 1114：按序打印
weixin_35338624的博客
07-18 579
题目描述 我们提供了一个类： public class Foo { public void one() { print("one"); } public void two() { print("two"); } public void three() { print("three"); } } 三个不同的线程将会共用一个Foo实例。 线程 A 将会调用 one() 方法 线程...
LeetCode：按序打印【1114】
weixin_30847271的博客
07-29 192
LeetCode：按序打印【1114】 题目描述 我们提供了一个类： 1 2 3 4 5 publicclassFoo { publicvoidone() { print("one"); } publicvoidtwo() { print("two"); } publicvoidthree() { print...
力扣 1114. 按序打印 C++多线程
xiji333的博客
09-06 399
https://leetcode-cn.com/problems/print-in-order/ 思路：条件变量就行了。 class Foo { public: Foo() { } void first(function<void()> printFirst) { unique_lock<mutex> lck(mtx); cv.wait(lck,func1); // printFirst()
LeetCode 1114 按序打印（多种解决）
欧阳子遥的博客
02-16 615
题目 代码实现： 写法一： class Foo { public Foo() { } volatile int count = 1; public void first(Runnable printFirst) throws InterruptedException { count++; // printFirst.run() outputs "first". Do not change or remov
LeetCode 1114 按序打印
liqingtx的专栏
03-28 317
题目： 我们提供了一个类： public class Foo { public void one() { print("one"); } public void two() { print("two"); } public void three() { print("three"); } } 三个不同的线程将会共用一个Foo实例。 线程 A 将会调用 one() 方法 线程 ...
Leetcode 1114. 按序打印 Java多线程编程
wwxy1995的博客
07-23 292
由于三个线程只需要按序打印一次，采用Java并发编程艺术最简单的等待通知机制。 class Foo { private boolean isPrintSecond = false; private boolean isPrintThird = false; private Object lock = new Object(); public Foo() {} public void first(Runnable printFirst) throws ...
LeetCode 1114.按序打印【多线程互斥量】
独钓门前月
11-07 315
1114. 按序打印 题意： 我们提供了一个类： public class Foo { public void first() { print(“first”); } public void second() { print(“second”); } public void third() { print(“third”); } } 三个不同的线程将会共用一个 Foo 实例。 线程 A 将会调用 first() 方法 线程 B 将会调用 second() 方法 线程 C 将会调用 third() 方法 请
【LeetCode-多线程】1114. 按序打印
HeavenDan的博客
11-25 559
目录一、题目二、解决1、原子类变量2、Semaphore代码-版本1代码-版本23、Synchronized代码-版本1：Synchronized Method代码-版本2：Synchronized on Object代码-版本3：Synchronized on Two Objects4、Condition Variable三、参考 一、题目 我们提供了一个类： public class Foo { public void first() { print("first"); } public vo
C练题笔记之：Leetcode-1114. 按序打印
lingjinyue的博客
01-06 718
题目： 给你一个类： 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() 方法 ...
LeetCode 多线程 1114. 按序打印
Alex
01-08 343
1114. 按序打印 Ideas 并发执行问题是多线程要解决的经典问题，此题是典型的执行屏障问题，因此我们需要构造几把锁来确保执行顺序。 题目要求按顺序依次执行三个方法，为了保证线程的执行顺序，可以在方法之间创建一些锁，即第二个方法必须在第一个方法之后执行，第三个方法必须在第二个方法之后执行。 有两个依赖关系，所以我们定义两把锁，firstJobDone 和 secondJobDone，分别表示 first() 任务是否执行完毕和 second() 任务是否执行完毕。 我们来分析一下： 首先 first(
【LeetCode1114】按序打印（多线程，信号量）
发现问题，并解决问题，批判性思维
03-18 926
文章目录一、题目二、思路三、代码 一、题目 二、思路 第一次在leetcode上做这种多线程题目，对于这种“同步”问题，需要明白线程在哪里需要阻塞（对应PV操作中的P），再找对应的V部分（释放资源）。并且题目这里不要求考察临界资源的访问（互斥关系），只需要考虑同步关系。先想的printB之前需要阻塞，因为需要等A完成打印，所以此处需要Pa操作（如下图），而V部分是资源释放的地方，即A打印后需要Va，即唤醒B可以开始打印了。B和C之间的关系同理。 a同步信号量：可以理解为是B要获取的A打印后的资源，初值为
LeetCode（多线程）- 1114. 按序打印
陆氪和他的那些代码
01-13 387
题目链接：点击打开链接 题目大意：略。 解题思路：略。 相关企业 爱奇艺 微软（Microsoft） AC 代码 // 解决方案(1) class Foo { public Foo() { } volatile int count=1; public void first(Runnable printFirst) throws InterruptedException { printFirst.run();
按序打印
zry15671554200的博客
03-16 175
欢迎访问我的blog http://www.codinglemon.cn/ 好久没有写leetCode的算法题了，先写一个简单的试试水。 1114. 按序打印 1. 题目描述 我们提供了一个类： public class Foo { public void first() { print("first"); } public void second() { print("second"); } public void third() { print("third"); } } 三个不同的线.
leetcode 线程题 1114. 按序打印
克克克克业业的学习记录
08-23 320
三种方法 保证线程按序打印
LeetCode多线程题库--1114 按序打印
qq_37217266的博客
12-07 368
LeetCode多线程题库--1114 按序打印题目描述多线程内容回顾并发问题Java中Volatile关键字相关概念Volatile原理Thread类中的方法：join()、sleep()、yield()之间的区别AtomicInteger简介题解 题目描述 我们提供了一个类： public class Foo { public void first() { print(“first”); } public void second() { print(“second”); } public void th
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值