Java使用信号量的生产者-消费者解决方案2套

在多线程环境下，生产者-消费者问题是一个经典的同步问题。Java提供了多种解决方案，其中一种是使用Semaphore信号量来实现同步。

下面我们将提供两个代码示例，分别演示同步队列和同步栈的生产者-消费者问题的解决方案。

同步队列示例

需要使用Semaphore信号量和队列实现生产者-消费者模式。具体实现请参考以下代码：

import java.util.LinkedList;
import java.util.Queue;
import java.util.Random;
import java.util.concurrent.Semaphore;

public class SynchronizedQueueDemo {
    private static final Semaphore empty = new Semaphore(1);
    private static final Semaphore full = new Semaphore(0);
    private static final Queue<Integer> queue = new LinkedList<>();

    public static void main(String[] args) {
        Thread producer = new Producer();
        Thread consumer = new Consumer();
        producer.start();
        consumer.start();
    }

    static class Producer extends Thread {
        private final Random random = new Random();

        @Override
        public void run() {
            while (true) {
                try {
                    empty.acquire();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                int v = random.nextInt(100);
                queue.offer(v);
                System.out.println("Producer: " + v);

                full.release();
            }
        }
    }

    static class Consumer extends Thread {
        @Override
        public void run() {
            while (true) {
                try {
                    full.acquire();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                int v = queue.poll();
                System.out.println("Consumer: " + v);

                empty.release();
            }
        }
    }
}

在这段代码中，我们使用了Semaphore信号量来保证队列的同步。当队列的元素数目达到上限时，生产者线程将被阻塞，直到队列中有元素被取出。当队列为空时，消费者线程将被阻塞，直到队列中有元素被加入。

同步栈示例

除了同步队列，我们还可以使用Semaphore信号量实现同步栈。具体实现请参考以下代码：

import java.util.Stack;
import java.util.concurrent.Semaphore;

public class SynchronizedStackDemo {
    private static final Semaphore semaphore = new Semaphore(1);
    private static final Stack<Integer> stack = new Stack<>();

    public static void main(String[] args) {
        Thread producer = new Producer();
        Thread consumer = new Consumer();
        producer.start();
        consumer.start();
    }

    static class Producer extends Thread {
        private int index = 0;

        @Override
        public void run() {
            while (true) {
                try {
                    semaphore.acquire();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                int v = index++;
                stack.push(v);
                System.out.println("Producer: " + v);

                semaphore.release();
            }
        }
    }

    static class Consumer extends Thread {
        @Override
        public void run() {
            while (true) {
                try {
                    semaphore.acquire();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                if (!stack.isEmpty()) {
                    int v = stack.pop();
                    System.out.println("Consumer: " + v);
                }

                semaphore.release();
            }
        }
    }
}

在这段代码中，我们使用了Semaphore信号量来保证栈的同步。当栈空时，消费者线程不会做任何操作。当栈满时，生产者线程将被阻塞，直到栈中有元素被取出。

通过这两个示例，我们可以看到，Semaphore信号量是一种强大的同步机制，可以应用于各种不同的同步问题。