leetcode 多线程

最新推荐文章于 2025-04-11 00:16:46 发布
最新推荐文章于 2025-04-11 00:16:46 发布
阅读量111 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/skycqd/article/details/118543660
版权

1114. 按序打印

class Foo {

    private volatile int a=1;
    public Foo() {
        
    }

    public void first(Runnable printFirst) throws InterruptedException {
        
        // printFirst.run() outputs "first". Do not change or remove this line.
        while(a!=1){

        }
        printFirst.run();
        a=2;
    }

    public void second(Runnable printSecond) throws InterruptedException {
        
        // printSecond.run() outputs "second". Do not change or remove this line.
        while(a!=2){

        }
        printSecond.run();
        a=3;
    }

    public void third(Runnable printThird) throws InterruptedException {
        
        // printThird.run() outputs "third". Do not change or remove this line.
        while(a!=3){

        }
        printThird.run();
    }
}

自选锁耗费cpu资源

Condition:

用condition await()方法阻塞

1115. 交替打印FooBar

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class FooBar {
    private int n;
    private Lock lock=new ReentrantLock();
    Condition a=lock.newCondition();
    Condition b=lock.newCondition();

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

    public void foo(Runnable printFoo) throws InterruptedException {
        
        for (int i = 0; i < n; i++) {
            if(i==0){
                printFoo.run();
                b.signal();
            }
            lock.lock();
            try {
                a.await();
                printFoo.run();
                b.signal();
            } catch (Exception e) {
                //TODO: handle exception
            } finally{
                lock.unlock();
            }
        }
    }

    public void bar(Runnable printBar) throws InterruptedException {
        
        for (int i = 0; i < n; i++) {
            lock.lock();
            try {
                b.await();
                printBar.run();
                a.signal();
            } catch (Exception e) {
                //TODO: handle exception
            } finally{
                lock.unlock();
            }
        }
    }
}

1116. 打印零与奇偶数

Lock+Condition:

    

import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.LockSupport;
import java.util.concurrent.locks.ReentrantLock;
import java.util.function.IntConsumer;

class ZeroEvenOdd {
    private int n;
    private static volatile int x=0;
    private Lock lock=new ReentrantLock();
    private Condition zero=lock.newCondition();
    private Condition even=lock.newCondition();
    private Condition odd=lock.newCondition();
    
    public ZeroEvenOdd(int n) {
        this.n = n;
    }

    // printNumber.accept(x) outputs "x", where x is an integer.
    public void zero(IntConsumer printNumber) throws InterruptedException {
        for(int i=0;i<n;i++){
            lock.lock();
            try {
                while(x!=0){
                    zero.await();
                }
                printNumber.accept(0);
                if(i%2==0){
                    x=1;
                    odd.signal();
                    
                }else{
                    x=2;
                    even.signal();
                    
                }
                
            } catch (Exception e) {
                //TODO: handle exception
            }finally{
                lock.unlock();
            }
        }
        
    }

    public void even(IntConsumer printNumber) throws InterruptedException {
        int k=n;
        if(k%2==0){
            k=k+1;
        }
        for(int i=2;i<k;i+=2){
            lock.lock();
            try{
                
                while(x!=2){
                    even.await();
                }
                printNumber.accept(i);
                x=0;
                zero.signal();
                

            }catch(Exception e){

            }finally{
                lock.unlock();
            }
        }
    }

    public void odd(IntConsumer printNumber) throws InterruptedException {
        int k=n;
        if(k%2==1){
            k=k+1;
        }
        for(int i=1;i<k;i+=2){
            lock.lock();
            try{
                
                while(x!=1){
                    odd.await();
                }
                printNumber.accept(i);
                x=0;
                zero.signal();
                

            }catch(Exception e){

            }finally{
                lock.unlock();
            }
        }
    }
   
}

    Semphore:

   

import java.util.concurrent.Semaphore;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.LockSupport;
import java.util.concurrent.locks.ReentrantLock;
import java.util.function.IntConsumer;

class ZeroEvenOdd {
    private int n;
    private Semaphore zero = new Semaphore(1);
    private Semaphore odd = new Semaphore(0);
    private Semaphore even = new Semaphore(0);

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

    // printNumber.accept(x) outputs "x", where x is an integer.
    public void zero(IntConsumer printNumber) throws InterruptedException {
        for (int i = 0; i < n; i++) {
            zero.acquire();
            printNumber.accept(0);
            if (i % 2 == 0) {
                odd.release();
            } else {
                even.release();
            }
        }

    }

    public void even(IntConsumer printNumber) throws InterruptedException {
        for (int i = 2; i <= n; i += 2) {
            even.acquire();
            printNumber.accept(i);
            zero.release();
        }
    }

    public void odd(IntConsumer printNumber) throws InterruptedException {

        for (int i = 1; i <= n; i += 2) {
            odd.acquire();
            printNumber.accept(i);
            zero.release();
        }
    }

    public static void main(String[] args) {
        ZeroEvenOdd zeroEvenOdd = new ZeroEvenOdd(10);
        IntConsumer intConsumer = new IntConsumer() {

            @Override
            public void accept(int value) {
                // TODO Auto-generated method stub
                System.out.println(value);
            }

        };
        new Thread(() -> {
            try {
                zeroEvenOdd.zero(intConsumer);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }).start();
        new Thread(() -> {
            try {
                zeroEvenOdd.odd(intConsumer);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }).start();
        new Thread(() -> {
            try {
                zeroEvenOdd.even(intConsumer);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }).start();
    }
}

LockSupport:

1117. H2O 生成

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.Semaphore;

class H2O {
    private volatile int hc=0;
    private volatile int oc=0;
    Semaphore h=new Semaphore(2);
    Semaphore o=new Semaphore(1);
    public H2O() {
        
    }

    public void hydrogen(Runnable releaseHydrogen) throws InterruptedException {
		
        // releaseHydrogen.run() outputs "H". Do not change or remove this line.
        h.acquire();
        releaseHydrogen.run();
        hc++;
        if(oc==1&&hc==2){
            oc=0;
            hc=0;
            o.release();
            h.release();
            h.release();
        }
        

    }

    public void oxygen(Runnable releaseOxygen) throws InterruptedException {
        
        // releaseOxygen.run() outputs "O". Do not change or remove this line.
        o.acquire();
		releaseOxygen.run();
        oc++;
        if(oc==1&&hc==2){
            oc=0;
            hc=0;
            o.release();
            h.release();
            h.release();
        }
        
        
        
    }
}

1195. 交替打印字符串

import java.util.concurrent.Semaphore;
import java.util.function.IntConsumer;

class FizzBuzz {
    private int n;
    private Semaphore fizz=new Semaphore(0);
    private Semaphore buzz=new Semaphore(0);
    private Semaphore fizzbuzz=new Semaphore(0);
    private Semaphore number=new Semaphore(1);

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

    // printFizz.run() outputs "fizz".
    public void fizz(Runnable printFizz) throws InterruptedException {
        for(int i=1;i<=n;++i){
            if(i%3==0&&i%15!=0){
                fizz.acquire();
                printFizz.run();
                f(i+1);
            }
        }
    }

    // printBuzz.run() outputs "buzz".
    public void buzz(Runnable printBuzz) throws InterruptedException {
        for(int i=1;i<=n;++i){
            if(i%5==0&&i%15!=0){
                buzz.acquire();
                printBuzz.run();
                f(i+1);
            }
        }
        
    }

    // printFizzBuzz.run() outputs "fizzbuzz".
    public void fizzbuzz(Runnable printFizzBuzz) throws InterruptedException {
        for(int i=1;i<=n;++i){
            if(i%15==0){
                fizzbuzz.acquire();
                printFizzBuzz.run();
                f(i+1);
            }
        }
        
    }

    // printNumber.accept(x) outputs "x", where x is an integer.
    public void number(IntConsumer printNumber) throws InterruptedException {
        for(int i=1;i<=n;++i){
            if(i%3!=0&&i%5!=0){
                number.acquire();
                printNumber.accept(i);
                f(i+1);
                
            }
        }
        
    }
    void f(int k){
        if(k%3==0&&k%15!=0){
            fizz.release();
            return ;
            
        }
        if(k%5==0&&k%15!=0){
            buzz.release();
            return ;
           
        }
        if(k%15==0){
            fizzbuzz.release();
            return ;
            
        }
        number.release();
    }
}

1226. 哲学家进餐

​
import java.util.concurrent.Semaphore;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class DiningPhilosophers {
    private Semaphore[] semaphores=new Semaphore[5];
    private int n=5;
    private volatile int[] a=new int[5];
    private Lock lock=new ReentrantLock();

    public DiningPhilosophers() {
        for(int i=0;i<5;++i){
            semaphores[i]=new Semaphore(1);
        }
        
    }

    // call the run() method of any runnable to execute its code
    public void wantsToEat(int philosopher,
                           Runnable pickLeftFork,
                           Runnable pickRightFork,
                           Runnable eat,
                           Runnable putLeftFork,
                           Runnable putRightFork) throws InterruptedException {
            
        
        lock.lock();
        try {
            semaphores[philosopher].acquire();
            pickRightFork.run();
            semaphores[(philosopher-1+n)%n].acquire();
            pickLeftFork.run();
            eat.run();
            semaphores[philosopher].release();
            putRightFork.run();
            semaphores[(philosopher-1+n)%n].release();
            putLeftFork.run();
            
        } catch (Exception e) {
            //TODO: handle exception
        }finally{
            lock.unlock();
        }

    }
}

​

skycqd
关注
一文详解leetcode多线程同步问题
木心算法
10-10 379
多线程问题在日常的开发工作中很是常见，同时也是很重要的。多线程本身比较复杂，调试困难，在提高效率的同时，对线程安全也有更高的要求，因此多线程之间的同步是多线程问题的一个很重要的知识点。在面试过程中，也是判断候选人能力的一个很重要的考察点。 本文针对leetcode上的一些多线程同步问题进行分析和总结，并尝试对同一问题使用常见的多线程同步的不同解决方法，以期能够熟练掌握多线程同步（通信）相关内容。 基础知识 为保证线程安全，多个线程同一时刻只能有一个线程进入临界区，其他线程则等待，直到该线程退出临界区，所有.
【LeetCode-多线程】1242. 多线程网页爬虫
HeavenDan的博客
05-10 1182
1、Ctrl+W 或Ctrl+F4 关闭当前标签页或弹出窗口。 2、Ctrl+Tab 下一个标签页 Ctrl+Shift+Tab 上一个标签页 Ctrl+L：定位URL
Leetcode多线程
量子孤岛
08-12 392
1114. 按序打印 原题链接 class Foo { public: Foo() { m2.lock(); m3.lock(); } void first(function<void()> printFirst) { printFirst(); m2.unlock(); ...
学透并发编程——LeetCode多线程协作经典题
Hopefully Sky的博客
11-09 1752
LeetCode上专门的多线程题目版块，本文通过解决几道leetCode上的多线程协作交替打印的编程题，来加深对并发编程的理解，并训练一下并发编程思想。
LeetCode之多线程
Jak的博客
09-10 364
2181. 合并零之间的节点1114. 按序打印1115. 交替打印 FooBar1116. 打印零与奇偶数1117. H2O 生成1195. 交替打印字符串1226. 哲学家进餐
leetcode多线程专题
weixin_42151929的博客
10-12 295
1.经典哲学家进餐问题 参考：https://blog.csdn.net/Yun_Ge/article/details/89177918 避免死锁共有三种策略：(wait和signal是线程的函数，lock和unlock是mutex的函数，wait和signal函数中可以使用condition_variable类型的变量，该类型变量有wait(lock)和notify_one()函数（库函数）) 保证同时饥饿的哲学家数量小于5，总之就是所有的哲学家不能同时进餐。（定义信号量count，保证至少有一个人
Leetcode之多线程编程题
qq_43649937的博客
10-20 386
java JUC
LeetCode_多线程
sc179的博客
08-20 478
目录哲学家进餐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多线程专区例举c++异步编程（c++11~17）
黑色低级高中生的博客
07-18 1011
目录前言说明效率环境题目1114. 按序打印题目描述题目分析before codingFoo v1测试与分析不要在condition_variable::wait中无条件等待Foo v2 前言 本博文将通过对力扣平台上多线程专区中的几道例题进行解析，通过使用不同的异步模型求解问题来对c++语言所支持的异步编程方式作一通览 说明 效率 基本不考虑探究最优解法这一过程，仅考虑使用符合第一直觉的方法并尽量雨露均沾 环境 msvc 16.0 clion 2021.1.2 code space Github Rep
LeetCode 多线程 1116. 打印零与奇偶数
Alex
07-18 406
1116. 打印零与奇偶数 Ideas 有几个线程就用几个信号量，最先开始的信号量初始化为1，其它初始化为0，然后根据条件判断实现同步。 多线程的问题好多都是：锁自己，解锁别人。 Code from threading import Semaphore class ZeroEvenOdd: def __init__(self, n): self.n = n + 1 self.zero_lock = Semaphore(1) self.even_lo
【Leetcode多线程】- Leetcode1114 按序打印
Mind_programmonkey的博客
05-18 354
【Leetcode多线程】- Leetcode1114 按序打印 我们提供了一个类： public class Foo { public void first() { print(“first”); } public void second() { print(“second”); } public void third() { print(“third”); } } 三个不同的线程 A、B、C 将会共用一个 Foo 实例。 一个将会调用 first() 方法 一个将会调用 second() 方法 还有一
多线程leetcode-XY.Multithread:练习LeetCode多线程
06-30
本项目“多线程LeetCode-XY.Multithread”专注于通过解决LeetCode上的多线程问题来提升对这一技术的理解和应用。 LeetCode是一个在线平台，提供了一系列算法和数据结构题目，旨在帮助程序员提高技能，准备面试，并...
多线程leetcode-leetcode-go:leetcode-go
06-30
多线程leetcode leetcode-go # 标题 解决方案 选项 困难 标签 0001 二和 2 简单的 hashmap 0002 两个数字相加 2 中等的 singlylinkedlist ， recursion 0003 无重复字符的最长子串 中等的 0004 两个有序数组的中位数...
springboot集成kafka，后续需要通过flask封装restful接口
make_progress_go的博客
04-08 741
Spring Boot作为一个轻量级的、用于构建微服务的框架，提供了与Kafka的整合支持，使得在Spring Boot应用中使用Kafka变得简单快捷。通过Spring Boot提供的spring-kafka项目，可以轻松地在Spring Boot应用中整合Kafka，实现消息的发送和接收。此外，Spring Boot提供的Actuator模块可以帮助监控Kafka的性能和健康状况。为了接收Kafka消息，可以定义一个服务类，并使用@KafkaListener注解来监听特定的主题。
C++：了解string类的重要函数
2301_81791624的博客
04-08 984
对于常用的一些string的函数，掌握上面的足以应对遇到的绝大部分情况了，并且我们可以看出封装了一个这样的字符串类后，我们以后再使用字符串就可以更加简洁更加方便了。后面会写一篇文章来进行对一些重要函数的模拟实现来帮助大家更加深入的了解这些函数的底层封装。
jdk21、17、11安装包
2401_87245171的博客
04-10 276
通过以上步骤，可完成JDK的安装与配置。若需进一步学习Java开发，建议结合IDE（如IntelliJ IDEA或Eclipse）进行项目实践。# 查看Java运行时版本 javac -version # 查看编译器版本。我用夸克网盘分享了「jdk」，
什么是虚拟线程？与普通线程的区别
最新发布
龚小帅的博客
04-11 636
虚拟线程的引入为 Java 并发编程提供了全新的选择，使得我们能够更加高效地处理大规模并发任务。它的轻量级、高效性和低内存占用，使得虚拟线程成为处理 IO 密集型任务的理想选择。在未来，随着 Java 生态的进一步发展，我们预计虚拟线程会在更多的领域得到应用，特别是在大规模并发处理和高性能计算领域。如果你目前还在使用传统的线程池来处理并发任务，虚拟线程无疑是一个值得尝试的技术，它可以大大简化你的代码并提升性能。
TreeMap源码分析与红黑树实现原理
m0_71749752的博客
04-08 895
TreeMap通过红黑树保证数据的有序性，同时提供 O(log n) 级别的查找、插入和删除操作。掌握红黑树的旋转（左旋、右旋）及平衡调整机制，可以更好地理解TreeMap的内部实现！
Class 文件和类加载机制
m0_73748193的博客
04-09 1225
Java 源码（.java）经过javac 编译器编译生成的字节码文件（.class由 JVM 识别执行，包含类的完整结构信息（如字段、方法、常量池、访问权限等）；是平台无关的中间代码。JVM 的操作对象是 Class 文件，JVM 把 Class 文件中描述类的数据结构加载到内存中，并对数据进行校验、解析和初始化，最终形成可以被 JVM 直接使用的类型，这个过程被称为类加载机制。其中最重要的三个概念就是：类加载器、类加载过程和类加载器的双亲委派模型。类加载器。
Java语言实现leetcode多线程题解
资源摘要信息:"本资源主要介绍并解答了leetcode上的多线程相关问题，通过Java语言进行实现。leetcode是一个在线编程题库，广泛用于程序员的技能测试和面试准备。题目按照难度分为三个等级：简单（easy）、中等...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值