Leetcode之多线程编程题

已于 2023-10-28 15:53:19 修改
阅读量297 收藏 2
点赞数 3
分类专栏： JUC并发编程 文章标签： leetcode 算法 职场和发展
于 2023-10-20 17:50:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43649937/article/details/133948387
版权

1116. 打印零与奇偶数

现有函数 printNumber 可以用一个整数参数调用，并输出该整数到控制台。

  • 例如，调用 printNumber(7) 将会输出 7 到控制台。

给你类 ZeroEvenOdd 的一个实例，该类中有三个函数：zero、even 和 odd 。ZeroEvenOdd 的相同实例将会传递给三个不同线程：

  • 线程 A：调用 zero() ，只输出 0
  • 线程 B：调用 even() ，只输出偶数
  • 线程 C：调用 odd() ，只输出奇数

修改给出的类，以输出序列 "010203040506..." ，其中序列的长度必须为 2n 。

实现 ZeroEvenOdd 类：

  • ZeroEvenOdd(int n) 用数字 n 初始化对象，表示需要输出的数。
  • void zero(printNumber) 调用 printNumber 以输出一个 0 。
  • void even(printNumber) 调用printNumber 以输出偶数。
  • void odd(printNumber) 调用 printNumber 以输出奇数。

Semaphore

class ZeroEvenOdd {
    private int n;
    private Semaphore zeroSema = new Semaphore(1);
    private Semaphore oddSema = new Semaphore(0);//奇数
    private Semaphore evenSema = new Semaphore(0);//偶数

    public ZeroEvenOdd(int n) {
        this.n = n;
    }

    public void zero(IntConsumer printNumber) throws InterruptedException {
        for (int i = 1; i <= n; i++) {
            zeroSema.acquire();
            printNumber.accept(0);
            if (i % 2!= 0) {//奇数
                oddSema.release();
            } else {
                evenSema.release();
            }
        }
    }

    public void even(IntConsumer printNumber) throws InterruptedException {
        for (int i = 1; i <= n; i++) {
            if (i % 2== 0) {//偶数 打印偶数 并释放zero的线程
                evenSema.acquire();
                printNumber.accept(i);
                zeroSema.release();
            }
        }
    }

    public void odd(IntConsumer printNumber) throws InterruptedException {
        for (int i = 1; i <= n; i++) {
            if (i % 2 != 0) {//奇数，打印奇数，并释放zero的线程
                oddSema.acquire();
                printNumber.accept(i);
                zeroSema.release();
            }
        }
    }
}

 synchronized

class ZeroEvenOdd {
    private int n;
    private final Object ob=new Object();
    private volatile int flag=0;


    public ZeroEvenOdd(int n) {
        this.n = n;
    }

    public void zero(IntConsumer printNumber) throws InterruptedException {
        for (int i = 1; i <= n; i++) {
            synchronized (ob){
                while (flag!=0){
                    ob.wait();
                }
                printNumber.accept(0);
                if(i%2==0)
                    flag=2;
                else
                    flag=1;
                ob.notifyAll();
            }
        }
    }

    public void even(IntConsumer printNumber) throws InterruptedException {
        for (int i = 1; i <= n; i++) {
            if (i % 2== 0) {//偶数 打印偶数 并释放zero的线程
                synchronized (ob){
                    while (flag!=2){
                        ob.wait();
                    }
                    printNumber.accept(i);
                    flag=0;
                    ob.notifyAll();
                }
            }
        }
    }

    public void odd(IntConsumer printNumber) throws InterruptedException {
        for (int i = 1; i <= n; i++) {
            if (i % 2!= 0) {//偶数 打印偶数 并释放zero的线程
                synchronized (ob){
                    while (flag!=1){
                        ob.wait();
                    }
                    printNumber.accept(i);
                    flag=0;
                    ob.notifyAll();
                }
            }
        }
    }
}

CountDownLatch

class ZeroEvenOdd {
    private int n;
    private CountDownLatch countDownLatch_zero=new CountDownLatch(0);

    private CountDownLatch countDownLatch_even=new CountDownLatch(1);

    private CountDownLatch countDownLatch_odd=new CountDownLatch(1);

    public ZeroEvenOdd(int n) {
        this.n = n;
    }

    public void zero(IntConsumer printNumber) throws InterruptedException {
        for (int i = 1; i <= n; i++) {
            countDownLatch_zero.await();
            printNumber.accept(0);
            countDownLatch_zero=new CountDownLatch(1);
            if (i % 2!= 0) {//奇数
               countDownLatch_odd.countDown();
            } else {
                countDownLatch_even.countDown();
            }
        }
    }

    public void even(IntConsumer printNumber) throws InterruptedException {
        for (int i = 1; i <= n; i++) {
            if (i % 2== 0) {//偶数 打印偶数 并释放zero的线程
                countDownLatch_even.await();
                printNumber.accept(i);
                countDownLatch_even=new CountDownLatch(1);
                countDownLatch_zero.countDown();
            }
        }
    }

    public void odd(IntConsumer printNumber) throws InterruptedException {
        for (int i = 1; i <= n; i++) {
            if (i % 2 != 0) {//奇数，打印奇数，并释放zero的线程
                countDownLatch_odd.await();
                printNumber.accept(i);
                countDownLatch_odd=new CountDownLatch(1);
                countDownLatch_zero.countDown();
            }
        }
    }
}

 Lock

class ZeroEvenOdd {
    private int n;
    private volatile int flag=0;
    Lock lock=new ReentrantLock();
    Condition condition_zero = lock.newCondition();
    Condition conditon_even = lock.newCondition();
    Condition condition_odd = lock.newCondition();


    public ZeroEvenOdd(int n) {
        this.n = n;
    }

    public void zero(IntConsumer printNumber) throws InterruptedException {
        for (int i = 1; i <= n; i++) {
            lock.lock();
            try{
                while (flag!=0){
                    condition_zero.await();
                }
                printNumber.accept(0);
                if(i%2==0) {
                    flag = 2;
                    conditon_even.signal();
                }
                else {
                    flag = 1;
                    condition_odd.signal();
                }
            }finally {
                lock.unlock();
            }
        }
    }

    public void even(IntConsumer printNumber) throws InterruptedException {
        for (int i = 1; i <= n; i++) {
            if (i % 2== 0) {//偶数 打印偶数 并释放zero的线程
                lock.lock();
                try {
                    while (flag != 2) {
                        conditon_even.await();
                    }
                    printNumber.accept(i);
                    flag = 0;
                    condition_zero.signal();
                }finally {
                    lock.unlock();
                }
                
            }
        }
    }

    public void odd(IntConsumer printNumber) throws InterruptedException {
        for (int i = 1; i <= n; i++) {
            if (i % 2!= 0) {//偶数 打印偶数 并释放zero的线程
                lock.lock();
                try {
                    while (flag != 1) {
                        condition_odd.await();
                    }
                    printNumber.accept(i);
                    flag = 0;
                    condition_zero.signal();
                }finally {
                    lock.unlock();
                }
            }
        }
    }
}

Thread.yield

class ZeroEvenOdd {
    private int n;
    private volatile int flag=0;


    public ZeroEvenOdd(int n) {
        this.n = n;
    }

    public void zero(IntConsumer printNumber) throws InterruptedException {
        for (int i = 1; i <= n; i++) {
                while (flag!=0){
                    Thread.yield();
                }
                printNumber.accept(0);
                if(i%2==0)
                    flag=2;
                else
                    flag=1;
            
        }
    }

    public void even(IntConsumer printNumber) throws InterruptedException {
        for (int i = 1; i <= n; i++) {
            if (i % 2== 0) {//偶数 打印偶数 并释放zero的线程
                    while (flag!=2){
                        Thread.yield();
                    }
                    printNumber.accept(i);
                    flag=0;
            }
        }
    }

    public void odd(IntConsumer printNumber) throws InterruptedException {
        for (int i = 1; i <= n; i++) {
            if (i % 2!= 0) {//偶数 打印偶数 并释放zero的线程
                    while (flag!=1){
                       Thread.yield();
                    }
                    printNumber.accept(i);
                    flag=0;
                }
        }
    }
}

LockSupport

LockSupport类的核心方法其实就两个：park()和unpark()，其中park()方法用来阻塞当前调用线程，unpark()方法用于唤醒指定线程。 这其实和Object类的wait()和signal()方法有些类似，但是LockSupport的这两种方法从语意上讲比Object类的方法更清晰，而且可以针对指定线程进行阻塞和唤醒。
LockSupport类使用了一种名为Permit（许可）的概念来做到阻塞和唤醒线程的功能，可以把许可看成是一种(0,1)信号量（Semaphore），但与 Semaphore 不同的是，许可的累加上限是1。 初始时，permit为0，当调用unpark()方法时，线程的permit加1，当调用park()方法时，如果permit为0，则调用线程进入阻塞状态。

class ZeroEvenOdd {
    private int n;
    private volatile int flag=0;
    private ConcurrentHashMap<String,Thread> map=new ConcurrentHashMap<>();


    public ZeroEvenOdd(int n) {
        this.n = n;
    }

    public void zero(IntConsumer printNumber) throws InterruptedException {
        map.put("zero",Thread.currentThread());
        for (int i = 1; i <= n; i++) {
                while (flag!=0){
                    LockSupport.park();
                }
                printNumber.accept(0);
                if(i%2==0) {
                    flag = 2;
                    LockSupport.unpark(map.get("even"));
                }
                else {
                    flag = 1;
                    LockSupport.unpark(map.get("odd"));
                }

        }
    }

    public void even(IntConsumer printNumber) throws InterruptedException {
        map.put("even",Thread.currentThread());
        for (int i = 1; i <= n; i++) {
            if (i % 2== 0) {//偶数 打印偶数 并释放zero的线程
                    while (flag!=2){
                        LockSupport.park();
                    }
                    printNumber.accept(i);
                    flag=0;
                    LockSupport.unpark(map.get("zero"));
            }
        }
    }

    public void odd(IntConsumer printNumber) throws InterruptedException {
        map.put("odd",Thread.currentThread());
        for (int i = 1; i <= n; i++) {
            if (i % 2!= 0) {//偶数 打印偶数 并释放zero的线程
                    while (flag!=1){
                       Thread.yield();
                    }
                    printNumber.accept(i);
                    flag=0;
                    LockSupport.unpark(map.get("zero"));
            }
        }
    }
}

1195. 交替打印字符串

编写一个可以从 1 到 n 输出代表这个数字的字符串的程序，但是：

  • 如果这个数字可以被 3 整除，输出 "fizz"。
  • 如果这个数字可以被 5 整除，输出 "buzz"。
  • 如果这个数字可以同时被 3 和 5 整除，输出 "fizzbuzz"。

例如，当 n = 15，输出： 1, 2, fizz, 4, buzz, fizz, 7, 8, fizz, buzz, 11, fizz, 13, 14, fizzbuzz。

假设有这么一个类：

class FizzBuzz {
  public FizzBuzz(int n) { ... }               // constructor
  public void fizz(printFizz) { ... }          // only output "fizz"
  public void buzz(printBuzz) { ... }          // only output "buzz"
  public void fizzbuzz(printFizzBuzz) { ... }  // only output "fizzbuzz"
  public void number(printNumber) { ... }      // only output the numbers
}

请你实现一个有四个线程的多线程版  FizzBuzz， 同一个 FizzBuzz 实例会被如下四个线程使用：

  1. 线程A将调用 fizz() 来判断是否能被 3 整除，如果可以，则输出 fizz。
  2. 线程B将调用 buzz() 来判断是否能被 5 整除，如果可以，则输出 buzz。
  3. 线程C将调用 fizzbuzz() 来判断是否同时能被 3 和 5 整除，如果可以，则输出 fizzbuzz。
  4. 线程D将调用 number() 来实现输出既不能被 3 整除也不能被 5 整除的数字。

CyclicBarrier

class FizzBuzz {
    private int n;
    private CyclicBarrier cb = new CyclicBarrier(4);

    public FizzBuzz(int n) {
        this.n = n;
    }

    // printFizz.run() outputs "fizz".
    public void fizz(Runnable printFizz) throws InterruptedException, BrokenBarrierException {
        for (int i = 1; i <= n; i++) {
            if (i % 3 == 0 && i % 5 != 0) {
                printFizz.run();
            }
            cb.await();
        }
    }

    // printBuzz.run() outputs "buzz".
    public void buzz(Runnable printBuzz) throws InterruptedException, BrokenBarrierException {
        for (int i = 1; i <= n; i++) {
            if (i % 3 != 0 && i % 5 == 0) {
                printBuzz.run();
            }
            cb.await();
        }
    }

    // printFizzBuzz.run() outputs "fizzbuzz".
    public void fizzbuzz(Runnable printFizzBuzz) throws InterruptedException, BrokenBarrierException {
        for (int i = 1; i <= n; i++) {
            if (i % 3 == 0 && i % 5 == 0) {
                printFizzBuzz.run();
            }
            cb.await();
        }
    }

    // printNumber.accept(x) outputs "x", where x is an integer.
    public void number(IntConsumer printNumber) throws InterruptedException, BrokenBarrierException {
        for (int i = 1; i <= n; i++) {
            if (i % 3 != 0 && i % 5 != 0) {
                printNumber.accept(i);
            }
            cb.await();
        }
    }
}

山河亦问安
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
Leetcode多线程题目汇总
weixin_44137260的博客
05-11 486
1114. 按序打印 多种解法，都是多线程常用工具 volite： class Foo { private volatile int flag=-1; // private AtomicInteger firstJobDone = new AtomicInteger(0); public Foo() {} public void first(Runnable printFirst) throws InterruptedException { // pr
java笔试题算法-Multi-threading:多线程
06-03
java笔试题算法 Note ———— The code is not mine and collected for the educational purpose from various blogs/ web-pages and books. Many instances, I refactored the code and occasionally, re-write some portion to adjust well. MULTI-THREADING IN JAVA ——————————————————————— THREAD CLASS METHODS ———————————————————— public void start(): START A THREAD BY CALLING ITS run() METHOD public void run(): ENTRY POINT FOR THE THREAD public final vod setName(String tName): SET THE NAME OF THE THREAD public final vo
多线程leetcode-leetcode-java:leetcode上的题解，基于java语言
06-30
多线程 leetcode 前言 每天刷点leetcode，基于java语言实现。 leetcode上难度分三档：easy,medium,hard. 如下： easy medium Remove Nth Node From End of List Swap Nodes in Pairs Spiral Matrix Path Sum II Copy List with Random Pointer Building H2O Fizz Buzz Multithreaded hard Merge k Sorted Lists Reverse Nodes in k-Group Trapping Rain Water
Java~多线程算法实战， 三种方式解决LeetCode题目1116(1)
2401_83974370的博客
04-01 750
小编精心为大家准备了一手资料以上Java高级架构资料、源码、笔记、视频。Dubbo、Redis、设计模式、Netty、zookeeper、Spring cloud、分布式、高并发等架构技术【附】架构书籍BAT面试的20道高频数据库问题解析Java面试宝典Netty实战算法BATJ面试要点及Java架构师进阶资料266)][外链图片转存中…(img-9y3m2gXR-1711953863266)]以上Java高级架构资料、源码、笔记、视频。
LeetCode-1117. H2O 生成（多线程）
2.wa
02-03 447
Leetcode 题目描述 现在有两种线程，氢 oxygen 和氧 hydrogen，你的目标是组织这两种线程来产生水分子。 存在一个屏障（barrier）使得每个线程必须等候直到一个完整水分子能够被产生出来。 氢和氧线程会被分别给予 releaseHydrogen 和 releaseOxygen 方法来允许它们突破屏障。 这些线程应该三三成组突破屏障并能立即组合产生一个水分子。 你必须保证产生一...
多线程算法题目汇总
longlovefilm的博客
11-09 772
1 两个线程交替打印自然数 方法1： package com.lzg.flume.intercepter.thread.test21; public class Test { public static void main(String[] args) { Object o = new Object(); Thread thread1 = new Thread(new PrintNum(o), "thread1"); Thread thread.
LeetCode_多线程
sc179的博客
08-20 406
目录哲学家进餐1 题目描述2 解题（Java）交替打印字符串1 题目描述2 解题（Java）H2O 生成1 题目描述2 解题（Java）打印零与奇偶数1 题目描述2 解题（Java）交替打印FooBar1 题目描述2 解题（Java）按序打印1 题目描述2 解题（Java）2.1 解法1：共享变量2.2 解法2：信号量 哲学家进餐 1 题目描述 5 个沉默寡言的哲学家围坐在圆桌前，每人面前一盘意面。叉子放在哲学家之间的桌面上。（5 个哲学家，5 根叉子） 所有的哲学家都只会在思考和进餐两种行为间交替。哲学家
Leetcode多线程
量子孤岛
08-12 344
1114. 按序打印 原题链接 class Foo { public: Foo() { m2.lock(); m3.lock(); } void first(function<void()> printFirst) { printFirst(); m2.unlock(); ...
java面试题-leetcode题解之第274题H指数.zip
05-23
在准备Java面试时，除了H指数这样的问题，还需要熟悉其他常见的算法题目，如二分查找、动态规划、回溯法等，并熟练运用Java集合框架、多线程、网络编程、设计模式等核心知识。LeetCode提供了丰富的练习题，可以帮助...
java-leetcode题解之第146题LRU缓存.zip
06-17
在实际编程中，可能还需要考虑并发安全，如果在多线程环境下使用，可以使用ConcurrentHashMap替换HashMap，使用LinkedBlockingDeque替换LinkedList，并使用synchronized关键字进行同步控制。 总的来说，Java实现LRU...
java-leetcode题解之第824题山羊拉丁文.zip
05-29
在本压缩包“java-leetcode题解之第824题山羊拉丁文.zip”中，包含的是关于Java编程语言解决LeetCode算法题目的代码实现，特别是针对第824题“山羊拉丁文”（Goat Latin）的解答。LeetCode是一个在线平台，它提供了...
java-leetcode题解之第622题设计循环队列.zip
06-12
在本压缩包中，我们关注的是Java编程语言与LeetCode平台上的第622题——设计循环队列。循环队列是一种数据结构，它在数组或链表的基础上实现了队列的特点，同时通过巧妙的设计使得“出队”和“入队”的操作更为高效...
c#-Leetcode面试题解之第14题最长公共前缀.zip
04-06
本压缩包文件“c#-Leetcode面试题解之第14题最长公共前缀.zip”显然是针对LeetCode中的第14题——“最长公共前缀”（Longest Common Prefix）提供的解决方案。在这个问题中，我们需要找到一个字符串数组中的最长公共...
LeetCode 多线程
zlb_zlb的博客
08-19 166
做多线程编程题，要根据n大小，顺序打印"010203.....0n"，过程中遇到了函数引用、typing数据类型。以题目为具体代码在这里做个记录。typing的用法python文档，多线程python文档 函数引用：将函数传入线程中，如下，将 printNumber传入三个子线程中。t_zero绑定到 z对象的zero方法，传入参数args=(printNumber,))，其中printNumber的类型为'Callable[[int], None]'，此类型表示传入参数是一个函数，该函数参数类型为...
[Leetcode] 多线程
chinanfsk的博客
08-29 625
前言 Java 多线程解题常用方法 & 工具类 类型 方法 说明 synchronized Object.wait(), Object.notify(), Object.notifyAll() 每一个用 synchronized 修饰的部分都是一个临界区，同一时间只允许一个线程访问 Lock Lock.lock(), Lock.unlock() 具体实现类：Reentr...
多线程算法题
暴走的后端
03-27 1241
一个文件中有10000个数，用Java实现一个多线程程序将这个10000个数输出到5个不用文件中（不要求输出到每个文件中的数量相同）。要求启动10个线程，两两一组，分为5组。每组两个线程分别将文件中的奇数和偶数输出到该组对应的一个文件中，需要偶数线程每打印10个偶数以后，就将奇数线程打印10个奇数，如此交替进行。同时需要记录输出进度，每完成1000个数就在控制台中打印当前完成数量，并在所有线程结束...
LeetCode-多线程-1114
chenshuang的博客
07-22 164
1114转载自： https://blog.csdn.net/fuxuemingzhu/article/details/95889253
leetcode多线程合集
princeteng's blogs
10-04 374
1114. 按序打印 与1116题类似，使用condition_variable. class Foo { public: Foo() { } mutex mtx; atomic<int> g{1}; condition_variable cv; void first(function<void()> printFirst) { unique_lock<mutex> lck(mtx);
C语言 | Leetcode C语言题解之第337题打家劫舍III
最新发布
m0_59237910的博客
08-15 384
C语言 | Leetcode C语言题解之第337题打家劫舍III
java在线笔试题题库
06-21
### 回答1： Java在线笔试题题库是一种在线教育平台，它为学生和从事软件开发的专业人士提供丰富的Java语言相关题库和测试题。这种题库涵盖了Java编程中的各种知识与技巧，包括基础概念、语法结构、数据类型、流程控制、集合、IO、多线程、网络编程等内容。 Java在线笔试题题库为Java初学者及进阶者提供了一个良好的学习和测试平台，使得学生们能够轻松掌握Java编程的基础知识，提高编程能力，更好地应对实际开发需求。对于企业招聘和团队培训具有很高的实用性和价值，能够帮助企业和团队筛选和提升Java开发人员的技能。 Java在线笔试题题库的题目针对不同的难度级别设置了不同的分值，学生可以通过解答这些题目来检验自己的掌握程度。题目还配有详细的解答和代码示例，帮助学生深入了解Java编程的原理和应用。 总之，Java在线笔试题题库提供了一个便捷和有效的学习和测试平台，用于提高Java开发人员的技能和能力，是学生和企业招聘方都值得信赖和应用的一种在线教育平台。 ### 回答2： Java在线笔试题题库是一个集成了大量Java编程语言相关的笔试题的网站或应用，旨在为准备Java笔试或者入职Java相关工作的个人和企业提供方便。Java在线笔试题题库中的题目涵盖了Java语言的所有方面，包括基础语法、面向对象编程、集合框架、异常处理、多线程等。通过这些题目的练习和掌握，考生可以提高Java编程的实战能力，掌握Java程序设计的核心思路。同时，Java在线笔试题题库也为企业提供了选择和筛选合适人才的重要参考依据，帮助企业通过笔试考察候选人Java编程的能力，进一步挖掘潜在的优秀人才。需要注意的是，在提交答案之前，考生需要确保代码的正确性和可读性，并对复杂的代码或者实现逻辑给出详细的注释。在JAVA在线笔试题题库中获取好的成绩可以帮助个人和企业实现他们的目标，提高生产力和绩效。总之，Java在线笔试题题库是Java编程领域中非常重要的学习和招聘工具之一，对Java程序员的职业发展具有很大的推动作用。 ### 回答3： Java在线笔试题题库是为了帮助Java程序员提高编程能力和技能而建立的一个题库平台。该题库收录了Java的基础知识和高级知识的笔试题目，包括Java语言基础、Java面向对象编程、Java集合框架、Java异常处理、Java I/O等方面的题目。 Java在线笔试题题库可以帮助Java程序员进行自我学习和练习，同时也可以作为Java编程语言的面试题库，供企业HR和面试官使用。通过做题，Java程序员可以深入了解Java编程语言的各个方面，并弥补自己的知识漏洞，提高自己的编程能力和技能。 除了提供Java在线笔试题题库外，还有一些Java编程语言学习网站提供相应的练习和题目，比如LeetCode、HackerRank等，这些网站也可以帮助Java程序员提高编程能力和技能。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

山河亦问安

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值