java - 线程安全的多生产者问题

Question

我在现实生活中面临一个有趣的问题。我把问题简化到这里:

设计两个方法A()和一个方法B()。每种方法都可以被认为是产生一个元素原子(A 或 B)。化合物 A[N]B[M] 需要 N 个 A 原子和 M 个 B 原子。

在我们拥有 N 个 A 原子和 M 个 B 原子之前，对 A() 和 B() 的每次调用都将被阻塞。当我们到达 N 个 A 原子和 M 个 B 原子时，第一个 N 个 A() 调用和第一个 M 个 B() 调用将返回。例如，如果我进行 N+2 A() 调用，然后进行 M B() 调用，则前 N A() 调用和所有 M B() 调用都将返回。还会有 2 个 A() 调用仍然被阻止吗？

如何解决这个问题？我正在使用Java。

Answer 1

您可以使用BlockingQueues :

static class AtomA
{       
}

static class AtomB
{       
}

static class ChemicalCompound
{
    BlockingQueue<AtomA> as = new LinkedBlockingQueue<AtomA>();
    BlockingQueue<AtomB> bs = new LinkedBlockingQueue<AtomB>();

    public ChemicalCompound(int na, int nb)
    {
        while (na-- != 0) as.add(new AtomA());
        while (nb-- != 0) bs.add(new AtomB());
    }

    public AtomA A() throws InterruptedException
    {
        return as.take();
    }

    public AtomB B() throws InterruptedException
    {
        return bs.take();
    }
}

public static void main(String[] args) throws Exception
{       
    final ChemicalCompound cc = new ChemicalCompound(2, 3);

    Thread ta = new Thread(new Runnable(){
        @Override
        public void run()
        {
            while (true)
            {
                try
                {
                    cc.A();
                    System.out.println("Got a A!");
                    Thread.sleep(100);
                }
                catch (InterruptedException e)
                {
                    e.printStackTrace();
                }
            }
        }           
    });
    ta.start();

    Thread tb = new Thread(new Runnable(){
        @Override
        public void run()
        {
            while (true)
            {
                try
                {
                    cc.B();
                    System.out.println("Got a B!");
                    Thread.sleep(100);
                }
                catch (InterruptedException e)
                {
                    e.printStackTrace();
                }
            }
        }           
    });
    tb.start();

    ta.join();
    tb.join();

    return;
}

Thread.sleep 只是为了演示线程可能的交错，但当然“在生产中”会删除它们。

结果:

Got a A!
Got a B!
Got a A!
Got a B!
Got a B!