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

Leetcode之多线程编程题

2024-01-31 111
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 现有函数 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线程
山河亦问安
目录
相关文章
游客5fdji2pvmf8888
|
4天前
|
设计模式 Java 开发者
Java多线程编程的陷阱与解决方案####
本文深入探讨了Java多线程编程中常见的问题及其解决策略。通过分析竞态条件、死锁、活锁等典型场景，并结合代码示例和实用技巧，帮助开发者有效避免这些陷阱，提升并发程序的稳定性和性能。 ####
游客5fdji2pvmf8888
29 16
游客5fdji2pvmf8888
|
7天前
|
数据采集 存储 数据处理
Python中的多线程编程及其在数据处理中的应用
本文深入探讨了Python中多线程编程的概念、原理和实现方法，并详细介绍了其在数据处理领域的应用。通过对比单线程与多线程的性能差异，展示了多线程编程在提升程序运行效率方面的显著优势。文章还提供了实际案例，帮助读者更好地理解和掌握多线程编程技术。
游客5fdji2pvmf8888
26 5
游客sjjs6jgz4gp7m1
|
6天前
|
API Android开发 iOS开发
深入探索Android与iOS的多线程编程差异
在移动应用开发领域，多线程编程是提高应用性能和响应性的关键。本文将对比分析Android和iOS两大平台在多线程处理上的不同实现机制，探讨它们各自的优势与局限性，并通过实例展示如何在这两个平台上进行有效的多线程编程。通过深入了解这些差异，开发者可以更好地选择适合自己项目需求的技术和策略，从而优化应用的性能和用户体验。
游客sjjs6jgz4gp7m1
16 2
游客762btuqu5wybw666
|
11天前
|
存储 安全 Java
Java多线程编程中的并发容器：深入解析与实战应用####
在本文中，我们将探讨Java多线程编程中的一个核心话题——并发容器。不同于传统单一线程环境下的数据结构，并发容器专为多线程场景设计，确保数据访问的线程安全性和高效性。我们将从基础概念出发，逐步深入到`java.util.concurrent`包下的核心并发容器实现，如`ConcurrentHashMap`、`CopyOnWriteArrayList`以及`BlockingQueue`等，通过实例代码演示其使用方法，并分析它们背后的设计原理与适用场景。无论你是Java并发编程的初学者还是希望深化理解的开发者，本文都将为你提供有价值的见解与实践指导。 --- ####
游客762btuqu5wybw666
25 3
叫个什么名字
|
20天前
|
存储 安全 Java
Java多线程编程的艺术：从基础到实践####
本文深入探讨了Java多线程编程的核心概念、应用场景及其实现方式，旨在帮助开发者理解并掌握多线程编程的基本技能。文章首先概述了多线程的重要性和常见挑战，随后详细介绍了Java中创建和管理线程的两种主要方式：继承Thread类与实现Runnable接口。通过实例代码，本文展示了如何正确启动、运行及同步线程，以及如何处理线程间的通信与协作问题。最后，文章总结了多线程编程的最佳实践，为读者在实际项目中应用多线程技术提供了宝贵的参考。 ####
叫个什么名字
60 5
ShaFaChuang-36210
|
17天前
|
监控 安全 Java
Java中的多线程编程：从入门到实践####
本文将深入浅出地探讨Java多线程编程的核心概念、应用场景及实践技巧。不同于传统的摘要形式，本文将以一个简短的代码示例作为开篇，直接展示多线程的魅力，随后再详细解析其背后的原理与实现方式，旨在帮助读者快速理解并掌握Java多线程编程的基本技能。 ```java // 简单的多线程示例：创建两个线程，分别打印不同的消息 public class SimpleMultithreading { public static void main(String[] args) { Thread thread1 = new Thread(() -> System.out.prin
ShaFaChuang-36210
36 1
请看我回答~
|
20天前
|
Java UED
Java中的多线程编程基础与实践
【10月更文挑战第35天】在Java的世界中，多线程是提升应用性能和响应性的利器。本文将深入浅出地介绍如何在Java中创建和管理线程，以及如何利用同步机制确保数据一致性。我们将从简单的“Hello, World!”线程示例出发，逐步探索线程池的高效使用，并讨论常见的多线程问题。无论你是Java新手还是希望深化理解，这篇文章都将为你打开多线程的大门。
请看我回答~
32 1
潇洒洒
|
27天前
|
安全 程序员 API
Pthread深度解析：掌握多线程编程的核心工具
【10月更文挑战第19天】
潇洒洒
57 10
萝卜带泥
|
20天前
|
安全 Java 编译器
Java多线程编程的陷阱与最佳实践####
【10月更文挑战第29天】 本文深入探讨了Java多线程编程中的常见陷阱，如竞态条件、死锁、内存一致性错误等，并通过实例分析揭示了这些陷阱的成因。同时，文章也分享了一系列最佳实践，包括使用volatile关键字、原子类、线程安全集合以及并发框架（如java.util.concurrent包下的工具类），帮助开发者有效避免多线程编程中的问题，提升应用的稳定性和性能。 ####
萝卜带泥
46 1
叫个什么名字
|
24天前
|
存储 设计模式 分布式计算
Java中的多线程编程：并发与并行的深度解析####
在当今软件开发领域，多线程编程已成为提升应用性能、响应速度及资源利用率的关键手段之一。本文将深入探讨Java平台上的多线程机制，从基础概念到高级应用，全面解析并发与并行编程的核心理念、实现方式及其在实际项目中的应用策略。不同于常规摘要的简洁概述，本文旨在通过详尽的技术剖析，为读者构建一个系统化的多线程知识框架，辅以生动实例，让抽象概念具体化，复杂问题简单化。 ####
叫个什么名字
77 4