AI 助理
文档备案控制台
开发者社区 云计算 文章 正文

Leetcode之多线程编程题

2024-01-31 333
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 现有函数 printNumber 可以用一个整数参数调用，并输出该整数到控制台。例如，调用 printNumber(7) 将会输出 7 到控制台。给你类 ZeroEvenOdd 的一个实例，该类中有三个函数：zero、even 和 odd 。ZeroEvenOdd 的相同实例将会传递给三个不同线程：

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 实例会被如下四个线程使用：


线程A将调用 fizz() 来判断是否能被 3 整除，如果可以，则输出 fizz。

线程B将调用 buzz() 来判断是否能被 5 整除，如果可以，则输出 buzz。

线程C将调用 fizzbuzz() 来判断是否同时能被 3 和 5 整除，如果可以，则输出 fizzbuzz。

线程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();
        }
    }
}


关键词：
线程编程
LeetCode编程
LeetCode多线程
LeetCode线程
山河亦问安
目录
相关文章
啦啦啦191
|
5月前
|
Java
如何在Java中进行多线程编程
Java多线程编程常用方式包括：继承Thread类、实现Runnable接口、Callable接口（可返回结果）及使用线程池。推荐线程池以提升性能，避免频繁创建线程。结合同步与通信机制，可有效管理并发任务。
啦啦啦191
244 6
欲揽西江月
|
8月前
|
Java API 微服务
为什么虚拟线程将改变Java并发编程？
为什么虚拟线程将改变Java并发编程？
欲揽西江月
396 83
pickstar-33775
|
10月前
|
机器学习/深度学习 消息中间件 存储
【高薪程序员必看】万字长文拆解Java并发编程！(9-2)：并发工具-线程池
🌟 ​大家好，我是摘星！​ 🌟今天为大家带来的是并发编程中的强力并发工具-线程池，废话不多说让我们直接开始。
pickstar-33775
388 0
站大爷
|
5月前
|
Java 调度 数据库
Python threading模块：多线程编程的实战指南
本文深入讲解Python多线程编程，涵盖threading模块的核心用法：线程创建、生命周期、同步机制（锁、信号量、条件变量）、线程通信（队列）、守护线程与线程池应用。结合实战案例，如多线程下载器，帮助开发者提升程序并发性能，适用于I/O密集型任务处理。
站大爷
504 0
蓝易云
|
6月前
|
算法 Java
Java多线程编程：实现线程间数据共享机制
以上就是Java中几种主要处理多线程序列化资源以及协调各自独立运行但需相互配合以完成任务threads 的技术手段与策略。正确应用上述技术将大大增强你程序稳定性与效率同时也降低bug出现率因此深刻理解每项技术背后理论至关重要.
蓝易云
449 16
蓝易云
|
Linux
Linux编程： 在业务线程中注册和处理Linux信号
通过本文，您可以了解如何在业务线程中注册和处理Linux信号。正确处理信号可以提高程序的健壮性和稳定性。希望这些内容能帮助您更好地理解和应用Linux信号处理机制。
蓝易云
251 26
蓝易云
|
Linux
Linux编程： 在业务线程中注册和处理Linux信号
本文详细介绍了如何在Linux中通过在业务线程中注册和处理信号。我们讨论了信号的基本概念，并通过完整的代码示例展示了在业务线程中注册和处理信号的方法。通过正确地使用信号处理机制，可以提高程序的健壮性和响应能力。希望本文能帮助您更好地理解和应用Linux信号处理，提高开发效率和代码质量。
蓝易云
277 17
游客5fdji2pvmf8888
|
设计模式 Java 开发者
Java多线程编程的陷阱与解决方案####
本文深入探讨了Java多线程编程中常见的问题及其解决策略。通过分析竞态条件、死锁、活锁等典型场景，并结合代码示例和实用技巧，帮助开发者有效避免这些陷阱，提升并发程序的稳定性和性能。 ####
游客5fdji2pvmf8888
243 16
栈江湖
|
存储 安全 Java
Java多线程编程秘籍：各种方案一网打尽，不要错过！
Java 中实现多线程的方式主要有四种：继承 Thread 类、实现 Runnable 接口、实现 Callable 接口和使用线程池。每种方式各有优缺点，适用于不同的场景。继承 Thread 类最简单，实现 Runnable 接口更灵活，Callable 接口支持返回结果，线程池则便于管理和复用线程。实际应用中可根据需求选择合适的方式。此外，还介绍了多线程相关的常见面试问题及答案，涵盖线程概念、线程安全、线程池等知识点。
栈江湖
833 2
aliyun0641063962-48771
|
缓存 Java 开发者
Java多线程编程的陷阱与最佳实践####
本文深入探讨了Java多线程编程中常见的陷阱，如竞态条件、死锁和内存一致性错误，并提供了实用的避免策略。通过分析典型错误案例，本文旨在帮助开发者更好地理解和掌握多线程环境下的编程技巧，从而提升并发程序的稳定性和性能。 ####
aliyun0641063962-48771
216 12

热门文章

最新文章

  • 1
    C#与JAVA线程间同步实现比较
  • 2
    网易面试：SpringBoot如何开启虚拟线程？
  • 3
    线程中的同步辅助类CountDownLatch
  • 4
    线程简介
  • 5
    C#基础知识回顾--线程传参
  • 6
    Python并发编程：多线程（threading模块）
  • 7
    线程间共享数据
  • 8
    线程同步之MUTEX
  • 9
    Android的进程与线程（2）按重要性划分等级的5种进程
  • 10
    进程与线程 thread （二）——线程概念
  • 1
    从零掌握贪心算法Java版：LeetCode 10题实战解析（上）
    383
  • 2
    两数之和(每天刷力扣hot100系列)
    252
  • 3
    最长连续序列(每天刷力扣hot100系列)
    280
  • 4
    力扣第一道困难题《3. 无重复字符的最长子串》，c++
    287
  • 5
    【LeetCode 热题100】DP 实战进阶：最长递增子序列、乘积最大子数组、分割等和子集（力扣300 / 152/ 416 ）（Go语言版）
    374
  • 6
    【LeetCode 热题100】BFS/DFS 实战：岛屿数量 & 腐烂的橘子（力扣200 / 994 ）（Go语言版）
    294
  • 7
    【LeetCode 热题100】BFS/DFS 实战：岛屿数量 & 腐烂的橘子（力扣200 / 994 ）（Go语言版）
    411
  • 8
    【LeetCode 热题100】回溯：括号生成 & 组合总和（力扣22 / 39 ）（Go语言版）
    386
  • 9
    【LeetCode 热题100】155：最小栈（详细解析）（Go语言版）
    344
  • 10
    【LeetCode 热题100】路径与祖先：二叉树中的深度追踪技巧（力扣33 / 81/ 153/154）（Go语言版）
    398

    • 相关电子书

    更多
  • 多IO线程优化版
  • 低代码开发师（初级）实战教程
  • 阿里巴巴DevOps 最佳实践手册
    • 下一篇
    云安全中心：病毒查杀