LeetCode 1116. 打印零与奇偶数 Semaphore

Leetcode 1116. 打印零与奇偶数

难度 中等90

假设有这么一个类：

class ZeroEvenOdd {
  public ZeroEvenOdd(int n) { ... }      // 构造函数
  public void zero(printNumber) { ... }  // 仅打印出 0
  public void even(printNumber) { ... }  // 仅打印出 偶数
  public void odd(printNumber) { ... }   // 仅打印出 奇数
}

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

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

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

 

示例 1：

输入：n = 2
输出："0102"
说明：三条线程异步执行，其中一个调用 zero()，另一个线程调用 even()，最后一个线程调用odd()。正确的输出为 "0102"。

示例 2：

输入：n = 5
输出："0102030405"

Semaphore信号量

原理：
semaphore.acquire()

获得，如果没了，等待，等待被释放为止！

semaphore.release();

释放，会将当前的信号量释放 + 1，然后唤醒等待的线程！
作用： 多个共享资源互斥的使用！并发限流，控制最大的线程数！

 

Java完整示例代码：

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

public class Semaphore1 {
    static class ZeroEvenOdd {
        private int n;

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

        Semaphore s1 = new Semaphore(1);
        Semaphore s2 = new Semaphore(0);
        Semaphore s3 = new Semaphore(0);

        // printNumber.accept(x) outputs "x", where x is an integer.
        public void zero(IntConsumer printNumber) throws InterruptedException {//打印0
            for (int i = 1; i <= n; i++) {//
                s1.acquire();//获得，信号量-1
                printNumber.accept(0);
                if (i % 2 == 0)
                    s2.release();//偶数//释放，信号量+1
                else
                    s3.release();//奇数//释放，信号量+1
            }
        }

        public void even(IntConsumer printNumber) throws InterruptedException {// 仅打印出 偶数
            for (int i = 2; i <= n; i += 2) {
                s2.acquire();
                printNumber.accept(i);
                s1.release();
            }
        }

        public void odd(IntConsumer printNumber) throws InterruptedException {// 仅打印出 奇数
            for (int i = 1; i <= n; i += 2) {
                s3.acquire();
                printNumber.accept(i);
                s1.release();
            }
        }
    }


    public static void main(String[] args) {

        ZeroEvenOdd zeroEvenOdd = new ZeroEvenOdd(5);

        new Thread(() -> {
            try {
                zeroEvenOdd.zero(new IntConsumer() {
                    @Override
                    public void accept(int value) {
                        System.out.print(value);
                    }
                });
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
        
        new Thread(() -> {
            try {
                zeroEvenOdd.even(new IntConsumer() {
                    @Override
                    public void accept(int value) {
                        System.out.print(value);
                    }
                });
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        new Thread(() -> {
            try {
                zeroEvenOdd.odd(new IntConsumer() {
                    @Override
                    public void accept(int value) {
                        System.out.print(value);
                    }
                });
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }).start();
    }
}