Java 我的生产者/消费者解决方案正确吗？

我正在努力学习更多关于线程的知识，并认为提出一个生产者/消费者问题的解决方案将是一个良好的开端。我对解决方案的限制之一是，消费者无法提前知道生产商的产量。代码按预期运行，我已经运行了很多次，但这并不意味着它没有缺陷。这个解决方案有什么问题吗

package Multithreading.ProducerConsumer;

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

public class ProducerConsumer
{
    private class Producer implements Runnable
    {
        @Override
        public void run()
        {
            for(int i = 0; i < 1000; i++)
            {
                try 
                {
                    canProduce.acquire();
                    mutex.acquire();
                    queue.add(i);
                    mutex.release();
                    canConsume.release();
                } 
                catch (InterruptedException ex) 
                {
                    ;
                }
            }
            try
            {
                canConsume.acquire();
                isTryingToFinish = true;
                canConsume.release();
            }
            catch (InterruptedException ex)
            {
                ;
            }
        }
    }

    private class Consumer implements Runnable
    {
        @Override
        public void run()
        {
            while(!isDone)
            {
                try
                {
                    canConsume.acquire();
                    mutex.acquire();
                    System.out.println(queue.pop());
                    if(isTryingToFinish && queue.isEmpty())
                    {
                        isDone = true;
                    }
                    mutex.release();
                    canProduce.release();
                }
                catch (InterruptedException ex)
                {
                    ;
                }
            }
        }
    }

    Semaphore canProduce;
    Semaphore canConsume;
    Semaphore mutex;
    boolean isTryingToFinish = false;
    boolean isDone = false;
    final static int bufferSize = 100;
    LinkedList<Integer> queue;

    public ProducerConsumer()
    {
        queue = new LinkedList<>();
        canProduce = new Semaphore(bufferSize);
        canConsume = new Semaphore(0);
        mutex = new Semaphore(1);
    }

    public void Go() throws InterruptedException
    {
        Thread p = new Thread(new Producer());
        Thread c = new Thread(new Consumer());
        p.start();
        c.start();
        p.join();
        c.join();
        System.out.println("Job Complete!");
    }

    public static void main(String[] args) throws InterruptedException
    {
        ProducerConsumer p = new ProducerConsumer();
        p.Go();
    }
}

---

你可以看看。这是c，但这不应该是个问题。

您应该在尝试块之前获取互斥锁/锁/etc，并以相反的顺序释放它们！！在最后一个街区！！此外，你的布尔人至少应该是最不稳定的