(多线程)leetcode1117. H2O 生成认识Java中的PV原语

布满荆棘的人生 2023-07-12 11:57 17阅读 0赞

现在有两种线程，氢 oxygen 和氧 hydrogen，你的目标是组织这两种线程来产生水分子。

存在一个屏障（barrier）使得每个线程必须等候直到一个完整水分子能够被产生出来。

氢和氧线程会被分别给予 releaseHydrogen 和 releaseOxygen 方法来允许它们突破屏障。

这些线程应该三三成组突破屏障并能立即组合产生一个水分子。

你必须保证产生一个水分子所需线程的结合必须发生在下一个水分子产生之前。

换句话说:

如果一个氧线程到达屏障时没有氢线程到达，它必须等候直到两个氢线程到达。  
如果一个氢线程到达屏障时没有其它线程到达，它必须等候直到一个氧线程和另一个氢线程到达。  
书写满足这些限制条件的氢、氧线程同步代码。

示例 1:

输入: "HOH"  
输出: "HHO"  
解释: "HOH" 和 "OHH" 依然都是有效解。  
示例 2:

输入: "OOHHHH"  
输出: "HHOHHO"  
解释: "HOHHHO", "OHHHHO", "HHOHOH", "HOHHOH", "OHHHOH", "HHOOHH", "HOHOHH" 和 "OHHOHH" 依然都是有效解。

限制条件:

输入字符串的总长将会是 3n, 1 ≤ n ≤ 50；  
输入字符串中的 “H” 总数将会是 2n；  
输入字符串中的 “O” 总数将会是 n。

思路：说白了就是控制个顺序。互相pv一下。可以去找一下我写的操作系统多线程控制。

class H2O {
    
        private Semaphore h = new Semaphore(2);
        private Semaphore o = new Semaphore(0);
    
        public H2O() {
        }
    
        public void hydrogen(Runnable releaseHydrogen) throws InterruptedException {
    		h.acquire();
            // releaseHydrogen.run() outputs "H". Do not change or remove this line.
            releaseHydrogen.run();
            o.release();
        }
    
        public void oxygen(Runnable releaseOxygen) throws InterruptedException {
            o.acquire(2);
            // releaseOxygen.run() outputs "O". Do not change or remove this line.
    		releaseOxygen.run();
            h.release(2);
        }
    }

# Semaphore简介 #

Semaphore，是JDK1.5的java.util.concurrent并发包中提供的一个并发工具类。

所谓Semaphore即 信号量 的意思。

这个叫法并不能很好地表示它的作用，更形象的说法应该是许可证管理器。

其作用在JDK注释中是这样描述的：

A counting semaphore.  
Conceptually, a semaphore maintains a set of permits.  
Each \{@link \#acquire\} blocks if necessary until a permit is available, and then takes it.  
Each \{@link \#release\} adds a permit, potentially releasing a blocking acquirer.  
However, no actual permit objects are used; the \{@code Semaphore\} just keeps a count of the number available and acts accordingly.

翻译过来，就是：

Semaphore是一个计数信号量。  
从概念上将，Semaphore包含一组许可证。  
如果有需要的话，每个acquire()方法都会阻塞，直到获取一个可用的许可证。  
每个release()方法都会释放持有许可证的线程，并且归还Semaphore一个可用的许可证。  
然而，实际上并没有真实的许可证对象供线程使用，Semaphore只是对可用的数量进行管理维护。  
2.Semaphore方法说明  
Semaphore的方法如下：

——Semaphore(permits)

初始化许可证数量的构造函数

——Semaphore(permits,fair)

初始化许可证数量和是否公平模式的构造函数

——isFair()

是否公平模式FIFO

——availablePermits()

获取当前可用的许可证数量

——acquire()

当前线程尝试去阻塞的获取1个许可证。

此过程是阻塞的，它会一直等待许可证，直到发生以下任意一件事：

当前线程获取了1个可用的许可证，则会停止等待，继续执行。  
当前线程被中断，则会抛出InterruptedException异常，并停止等待，继续执行。  
——acquire(permits)

当前线程尝试去阻塞的获取permits个许可证。

此过程是阻塞的，它会一直等待许可证，直到发生以下任意一件事：

当前线程获取了n个可用的许可证，则会停止等待，继续执行。  
当前线程被中断，则会抛出InterruptedException异常，并停止等待，继续执行。  
——acquierUninterruptibly()

当前线程尝试去阻塞的获取1个许可证(不可中断的)。

此过程是阻塞的，它会一直等待许可证，直到发生以下任意一件事：

当前线程获取了1个可用的许可证，则会停止等待，继续执行。  
——acquireUninterruptibly(permits)

当前线程尝试去阻塞的获取permits个许可证。

此过程是阻塞的，它会一直等待许可证，直到发生以下任意一件事：

当前线程获取了n个可用的许可证，则会停止等待，继续执行。  
——tryAcquire()

当前线程尝试去获取1个许可证。

此过程是非阻塞的，它只是在方法调用时进行一次尝试。

如果当前线程获取了1个可用的许可证，则会停止等待，继续执行，并返回true。

如果当前线程没有获得这个许可证，也会停止等待，继续执行，并返回false。

——tryAcquire(permits)

当前线程尝试去获取permits个许可证。

此过程是非阻塞的，它只是在方法调用时进行一次尝试。

如果当前线程获取了permits个可用的许可证，则会停止等待，继续执行，并返回true。

如果当前线程没有获得permits个许可证，也会停止等待，继续执行，并返回false。

——tryAcquire(timeout,TimeUnit)

当前线程在限定时间内，阻塞的尝试去获取1个许可证。

此过程是阻塞的，它会一直等待许可证，直到发生以下任意一件事：

当前线程获取了可用的许可证，则会停止等待，继续执行，并返回true。  
当前线程等待时间timeout超时，则会停止等待，继续执行，并返回false。  
当前线程在timeout时间内被中断，则会抛出InterruptedException一次，并停止等待，继续执行。  
——tryAcquire(permits,timeout,TimeUnit)

当前线程在限定时间内，阻塞的尝试去获取permits个许可证。

此过程是阻塞的，它会一直等待许可证，直到发生以下任意一件事：

当前线程获取了可用的permits个许可证，则会停止等待，继续执行，并返回true。  
当前线程等待时间timeout超时，则会停止等待，继续执行，并返回false。  
当前线程在timeout时间内被中断，则会抛出InterruptedException一次，并停止等待，继续执行。  
——release()

当前线程释放1个可用的许可证。

——release(permits)

当前线程释放permits个可用的许可证。

——drainPermits()

当前线程获得剩余的所有可用许可证。

——hasQueuedThreads()

判断当前Semaphore对象上是否存在正在等待许可证的线程。

——getQueueLength()

获取当前Semaphore对象上是正在等待许可证的线程数量。