[Leetcode] 多线程

最新推荐文章于 2025-03-14 20:22:19 发布
最新推荐文章于 2025-03-14 20:22:19 发布
阅读量665 收藏 1
点赞数
分类专栏： Leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/chinanfsk/article/details/100135337
版权
前言

Java 多线程解题常用方法 & 工具类

类型方法说明
synchronizedObject.wait(), Object.notify(), Object.notifyAll()每一个用 synchronized 修饰的部分都是一个临界区，同一时间只允许一个线程访问
LockLock.lock(), Lock.unlock()具体实现类：ReentrantLock
SemaphoreSemaphore.acquire(), Semaphore.release()信号量是一种计数器，用来保护一个或多个共享资源的访问
CountDownLatchCountDownLatch.await(), CountDownLatch.countDown()在完成一组正在其他线程中执行的操作之前，允许线程一直等待
CyclicBarrierCyclicBarrier.await()允许多个线程在某个集合点处进行互相等待
PhaserPhaser.arriveAndAwaitAdvance()把并发任务分成多个阶段运行，在开始下一阶段之前，当前阶段中的所有线程都必须执行完成
具体问题
按序打印

三个不同的线程将会共用一个 Foo 实例。

  • 线程 A 将会调用 one() 方法
  • 线程 B 将会调用 two() 方法
  • 线程 C 将会调用 three() 方法

请设计修改程序，以确保 two() 方法在 one() 方法之后被执行，three() 方法在 two() 方法之后被执行。

示例
输入：[1,3,2]
输出："onetwothree"
解释：输入 [1,3,2] 表示线程 A 将会调用 one() 方法，线程 B 将会调用 three() 方法，线程 C 将会调用 two() 方法。
正确的输出是 "onetwothree"。
解题思路
/* 解法一：synchronized */
class Foo {
	private Object lock;
	private boolean firstFlag, secondFlag;
	
    public Foo() {
        this.lock = new Object();
        this.firstFlag = false;
        this.secondFlag = false;
    }

    public void first(Runnable printFirst) throws InterruptedException {
        synchronized (lock) {
        	// printFirst.run() outputs "first". Do not change or remove this line.
        	printFirst.run();
        	firstFlag = true;
        	lock.notifyAll();
        }        
    }

    public void second(Runnable printSecond) throws InterruptedException {
        synchronized (lock) {
        	while (!firstFlag) {
        		lock.wait();
        	}
	        // printSecond.run() outputs "second". Do not change or remove this line.
	        printSecond.run();
	        secondFlag = true;
	        lock.notifyAll();
		}
    }

    public void third(Runnable printThird) throws InterruptedException {
        synchronized (lock) {
	        while (!secondFlag) {
	        	lock.wait();
	        }
	        // printThird.run() outputs "third". Do not change or remove this line.
	        printThird.run();	        
		}
    }
}

/* 解法二：Semaphore */
class Foo {
	private Semaphore semaphoreFirst, semaphoreSecond;
	
    public Foo() {
    	this.semaphoreFirst = new Semaphore(0); 
    	this.semaphoreSecond = new Semaphore(0);   
    }

    public void first(Runnable printFirst) throws InterruptedException {        
        // printFirst.run() outputs "first". Do not change or remove this line.
        printFirst.run();
        semaphoreFirst.release();
    }

    public void second(Runnable printSecond) throws InterruptedException {
        semaphoreFirst.acquire();
        // printSecond.run() outputs "second". Do not change or remove this line.
        printSecond.run();
        semaphoreSecond.release();
    }

    public void third(Runnable printThird) throws InterruptedException {
        semaphoreSecond.acquire();
        // printThird.run() outputs "third". Do not change or remove this line.
        printThird.run();
    }
}

/* 解法三：CountDownLatch */
class Foo {
	private CountDownLatch latchFirst, latchSecond;

    public Foo() {
    	this.latchFirst = new CountDownLatch(1);
    	this.latchSecond= new CountDownLatch(1);     
    }

    public void first(Runnable printFirst) throws InterruptedException {            
        // printFirst.run() outputs "first". Do not change or remove this line.
        printFirst.run();
        latchFirst.countDown();
    }

    public void second(Runnable printSecond) throws InterruptedException {
        latchFirst.await();
        // printSecond.run() outputs "second". Do not change or remove this line.
        printSecond.run();
        latchSecond.countDown();
    }

    public void third(Runnable printThird) throws InterruptedException {
        latchSecond.await();
        // printThird.run() outputs "third". Do not change or remove this line.
        printThird.run();
    }
}
交替打印FooBar

两个不同的线程将会共用一个 FooBar 实例。其中一个线程将会调用 foo() 方法，另一个线程将会调用 bar() 方法。
请设计修改程序，以确保 “foobar” 被输出 n 次。

示例
输入：n = 2
输出："foobarfoobar"
解释："foobar" 将被输出两次。
解题思路
/* 解法一：synchronized */
class FooBar {
    private int n;
    private Object lock;
    private boolean flag;

    public FooBar(int n) {
        this.n = n;
        this.lock = new Object();
        this.flag = false;
    }

    public void foo(Runnable printFoo) throws InterruptedException {        
        for (int i = 0; i < n; i++) {
            synchronized (lock) {
                while (flag) {
                    lock.wait();
                }
                // printFoo.run() outputs "foo". Do not change or remove this line.
                printFoo.run();
                flag = true;
                lock.notifyAll();
            }
        }
    }

    public void bar(Runnable printBar) throws InterruptedException {        
        for (int i = 0; i < n; i++) {
            synchronized (lock) {
                while (!flag) {
                    lock.wait();
                }
                // printBar.run() outputs "bar". Do not change or remove this line.
                printBar.run();
                flag = false;
                lock.notifyAll();
            }
        }
    }
}

/* 解法二：Semaphore */
class FooBar {
    private int n;
    private Semaphore semaphoreFirst, semaphoreSecond;

    public FooBar(int n) {
        this.n = n;
        this.semaphoreFirst = new Semaphore(1);
        this.semaphoreSecond = new Semaphore(0);
    }

    public void foo(Runnable printFoo) throws InterruptedException {        
        for (int i = 0; i < n; i++) {
            semaphoreFirst.acquire();
        	// printFoo.run() outputs "foo". Do not change or remove this line.
        	printFoo.run();
            semaphoreSecond.release();
        }
    }

    public void bar(Runnable printBar) throws InterruptedException {        
        for (int i = 0; i < n; i++) {
            semaphoreSecond.acquire();
            // printBar.run() outputs "bar". Do not change or remove this line.
        	printBar.run();
            semaphoreFirst.release();
        }
    }
}
打印零与奇偶数

相同的一个 ZeroEvenOdd 类实例将会传递给三个不同的线程：

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

每个线程都有一个 printNumber 方法来输出一个整数。请修改给出的代码以输出整数序列 010203040506… ，其中序列的长度必须为 2n。

示例
输入：n = 2
输出："0102"
说明：三条线程异步执行，其中一个调用 zero()，另一个线程调用 even()，最后一个线程调用odd()。正确的输出为 "0102"。
解题思路
/* 解法一：synchronized */
class ZeroEvenOdd {
    private int n;
    private Object lock;
    private boolean zeroFlag, oddFlag, evenFlag;
    
    public ZeroEvenOdd(int n) {
        this.n = n;
        this.lock = new Object();
        this.zeroFlag = true;
        this.oddFlag = true;
        this.evenFlag = false;
    }

    // printNumber.accept(x) outputs "x", where x is an integer.
    public void zero(IntConsumer printNumber) throws InterruptedException {
        for (int i = 0; i < n; i++) {
            synchronized (lock) {
                while (!zeroFlag) {
                    lock.wait();
                }    
                printNumber.accept(0);
                zeroFlag = false;
                lock.notifyAll();
            }
        }    
    }

    public void odd(IntConsumer printNumber) throws InterruptedException {
        for (int i = 1; i <= n; i += 2) {
            synchronized (lock) {
                while (zeroFlag || !oddFlag) {
                    lock.wait();
                }
                printNumber.accept(i);
                zeroFlag = true;
                oddFlag = false;
                evenFlag = true;                
                lock.notifyAll();
            }
        }    
    }

    public void even(IntConsumer printNumber) throws InterruptedException {
        for (int i = 2; i <= n; i += 2) {
            synchronized (lock) {
                while (zeroFlag || !evenFlag) {
                    lock.wait();
                }
                printNumber.accept(i);
                zeroFlag = true;
                oddFlag = true;
                evenFlag = false;                
                lock.notifyAll();
            }
        }    
    }
}

/* 解法二：Semaphore */
class ZeroEvenOdd {
    private int n;
    private Semaphore semaphoreZero, semaphoreOdd, semaphoreEven;
    
    public ZeroEvenOdd(int n) {
        this.n = n;
        this.semaphoreZero = new Semaphore(1);
        this.semaphoreOdd = new Semaphore(0);
        this.semaphoreEven = new Semaphore(0);
    }

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

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

现在有两种线程，氢 oxygen 和氧 hydrogen，你的目标是组织这两种线程来产生水分子。存在一个屏障（barrier）使得每个线程必须等候直到一个完整水分子能够被产生出来。氢和氧线程会被分别给予 releaseHydrogen 和 releaseOxygen 方法来允许它们突破屏障。这些线程应该三三成组突破屏障并能立即组合产生一个水分子。你必须保证产生一个水分子所需线程的结合必须发生在下一个水分子产生之前。
换句话说：

  • 如果一个氧线程到达屏障时没有氢线程到达，它必须等候直到两个氢线程到达。
  • 如果一个氢线程到达屏障时没有其它线程到达，它必须等候直到一个氧线程和另一个氢线程到达。

书写满足这些限制条件的氢、氧线程同步代码。

示例
输入："OOHHHH"
输出："HHOHHO"
解释："HOHHHO", "OHHHHO", "HHOHOH", "HOHHOH", "OHHHOH", "HHOOHH", "HOHOHH" 和 "OHHOHH" 依然都是有效解。
解题思路
/* 解法一：synchronized */
class H2O {
	private Object lock;
	private int hCount;
	
    public H2O() {
        this.lock = new Object();
        this.hCount = 0;
    }

    public void hydrogen(Runnable releaseHydrogen) throws InterruptedException {
		synchronized (lock) {
			while (hCount == 2) {
				lock.wait();
			}
	        // releaseHydrogen.run() outputs "H". Do not change or remove this line.
	        releaseHydrogen.run();
			hCount++;
			lock.notifyAll();
		}
    }

    public void oxygen(Runnable releaseOxygen) throws InterruptedException {
        synchronized (lock) {
        	while (hCount != 2) {
        		lock.wait();
        	}
	        // releaseOxygen.run() outputs "H". Do not change or remove this line.
			releaseOxygen.run();
			hCount = 0;
			lock.notifyAll();
		}
    }
}

/* 解法二：Semaphore */
class H2O {
    private Semaphore semaphoreH, semaphoreO;

    public H2O() {
        this.semaphoreH = new Semaphore(2);
        this.semaphoreO = new Semaphore(0);
    }

    public void hydrogen(Runnable releaseHydrogen) throws InterruptedException {
		semaphoreH.acquire();
        // releaseHydrogen.run() outputs "H". Do not change or remove this line.
        releaseHydrogen.run();
        semaphoreO.release();
    }

    public void oxygen(Runnable releaseOxygen) throws InterruptedException {
        semaphoreO.acquire(2);
        // releaseOxygen.run() outputs "H". Do not change or remove this line.
		releaseOxygen.run();
        semaphoreH.release(2);
    }
}
多线程leetcode编程题
Alice_whj的博客
06-07 654
假设线程A已经拥有了某个对象(不是类)的锁，而其它线程B、C想要调用这个对象的某个synchronized方法(或者代码块), 由于B、C线程在进入对象的synchronized方法(或者块)之前必须先获得该对象锁的拥有权，而恰巧该对象的锁目前正被线程A所占用，此时B、C线程就会被阻塞，进入一个地方去等待锁的释放，这个地方便是该对象的锁池。假设线程A调用了某个对象的wait()方法，线程A就会释放该对象的锁，同时线程A就进入到了该对象的等待池中，进入到等待池中的线程不会去竞争该对象的锁。
【LeetCode-多线程】1242. 多线程网页爬虫
HeavenDan的博客
05-10 1193
1、Ctrl+W 或Ctrl+F4 关闭当前标签页或弹出窗口。 2、Ctrl+Tab 下一个标签页 Ctrl+Shift+Tab 上一个标签页 Ctrl+L：定位URL
Leetcode多线程
量子孤岛
08-12 393
1114. 按序打印 原题链接 class Foo { public: Foo() { m2.lock(); m3.lock(); } void first(function<void()> printFirst) { printFirst(); m2.unlock(); ...
多线程(超详细) (ε≡٩(๑＞₃＜)۶ 一心向学)
最新发布
2303_80388948的博客
03-14 1758
总结： 进程与线程的区别 • 进程是包含线程的，每个进程至少有一个线程存在，即为主线程； • 进程是系统进行资源分配和调度的一个独立单位，线程是程序执行的最小单位； • 进程有自己的内存地址空间，线程值独享指令流执行的必要资源，如寄存器和栈； 线程安全问题 产生原因 1、「根本」操作系统对于线程的调度是随机的，抢占式执行 2、多个线程同时修改同一个变量 3、修改操作，不是原子的 4、内存可见性问题，引起的线程不安全问题 5、指令重排序，引起的线程不安全问题
leetcode多线程合集
princeteng's blogs
10-04 473
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);
Java基础之多线程(一)--概述、同步、死锁、单例模式
枫叶的专栏
06-30 713
概述： /* 进程：是一个正在执行中的程序。 每一个进程执行都有一个执行顺序。该顺序是一个执行路径，或者叫一个控制单元。 线程：就是进程中的一个独立的控制单元。 线程在控制着进程的执行。 一个进程中至少有一个线程。 Java VM 启动的时候会有一个进程java.exe. 该进程中至少一个线程负责java程序的执行。 而且这个线程运行的代码存在于main方法中。 该线程称之
LeetCode 多线程
zlb_zlb的博客
08-19 196
做多线程编程题，要根据n大小，顺序打印"010203.....0n"，过程中遇到了函数引用、typing数据类型。以题目为具体代码在这里做个记录。typing的用法python文档，多线程python文档 函数引用：将函数传入线程中，如下，将 printNumber传入三个子线程中。t_zero绑定到 z对象的zero方法，传入参数args=(printNumber,))，其中printNumber的类型为'Callable[[int], None]'，此类型表示传入参数是一个函数，该函数参数类型为...
多线程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 两个有序数组的中位数...
LeetCode多线程编程练习：XY.Multithread解析
资源摘要信息:"多线程leetcode-XY.Multithread:练习LeetCode多线程" 在本资源中，我们将详细探讨有关多线程编程的知识点，特别是通过LeetCode平台进行相关的编程练习。多线程是操作系统中的一个重要概念，它指的是...
一文详解leetcode多线程同步问题
木心算法
10-10 384
多线程问题在日常的开发工作中很是常见，同时也是很重要的。多线程本身比较复杂，调试困难，在提高效率的同时，对线程安全也有更高的要求，因此多线程之间的同步是多线程问题的一个很重要的知识点。在面试过程中，也是判断候选人能力的一个很重要的考察点。 本文针对leetcode上的一些多线程同步问题进行分析和总结，并尝试对同一问题使用常见的多线程同步的不同解决方法，以期能够熟练掌握多线程同步（通信）相关内容。 基础知识 为保证线程安全，多个线程同一时刻只能有一个线程进入临界区，其他线程则等待，直到该线程退出临界区，所有.
多线程
03-18
一、实验目的 1． 理解Java语言中线程的基本概念； 2． 掌握Java语言中线程的两种编写方法； 二、实验内容 1． 编写一个Java程序，创建并运行三个线程： 1) 第一个线程打印a字母100次 2) 第二个线程打印b字母100次 3) 第三个线程打印1~100的整数 采用继承Thread类的方式实现； 2． 利用Runnable接口实现与第1题相同的功能； 3． 测试一个Applet小应用程序，体会多线程程序的运行过程； 三、实验步骤 1． 按照要求编写第1题中的代码，并将其编译、运行。 1) 由于第一个线程和第二个线程的功能相同，因此只需要定义2个线程——字母打印线程、数字打印线程； 2) 编译并运行该Java程序，线程的运行结果是否有规律可循？ 2． 按照要求编写第2题中的代码，并将其编译、运行。 1) 程序编写的方式与第1种方式有何不同？
LeetCode之多线程
Jak的博客
09-10 380
2181. 合并零之间的节点1114. 按序打印1115. 交替打印 FooBar1116. 打印零与奇偶数1117. H2O 生成1195. 交替打印字符串1226. 哲学家进餐
LeetCode多线程
qq_44838943的博客
07-08 164
1114. 按序打印 我们提供了一个类： public class Foo { public void one() { print("one"); } public void two() { print("two"); } public void three() { print("three"); } } 三个不同的线程将会共用一个Foo实例。 线程 A 将会调用 one() 方法 线程 B 将会调用two() 方...
LeetCode_多线程
sc179的博客
08-20 502
目录哲学家进餐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-多线程-1114
chenshuang的博客
07-22 213
1114转载自： https://blog.youkuaiyun.com/fuxuemingzhu/article/details/95889253
多线程(单例设计模式)
峰峰的博客
02-07 260
###_多线程(单例设计模式) * 单例设计模式：保证类在内存中只有一个对象。 * 如何保证类在内存中只有一个对象呢？ * (1)控制类的创建，不让其他类来创建本类的对象。private * (2)在本类中定义一个本类的对象。Singleton s; * (3)提供公共的访问方式。  public static Singleton getInstance(){return s} * 单
LeetCode刷题笔记【多线程】
qq_43313035
07-21 692
文章目录交替打印FooBar打印零与奇偶数按序打印H2O 生成 交替打印FooBar 题目描述： 我们提供一个类： class FooBar { public void foo() { for (int i = 0; i < n; i++) { print("foo"); } } public void bar() { for (int i =...
LeetCode-1117. H2O 生成（多线程）
2.wa
02-03 509
Leetcode 题目描述 现在有两种线程，氢 oxygen 和氧 hydrogen，你的目标是组织这两种线程来产生水分子。 存在一个屏障（barrier）使得每个线程必须等候直到一个完整水分子能够被产生出来。 氢和氧线程会被分别给予 releaseHydrogen 和 releaseOxygen 方法来允许它们突破屏障。 这些线程应该三三成组突破屏障并能立即组合产生一个水分子。 你必须保证产生一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值