java - 线程不通信

Question

我正在制作一个程序，其中包含 x 个线程的池与共享 list 进行交互。在本例中，我使用 ArrayList 作为共享 list 。在我的程序中，线程代表了一个生物所拥有的工作。生物属于一个团体并共享一个用于执行工作的人工制品池。任何时候只有一个生物可以与水池互动。

出于某种原因，我一直遇到线程通信问题。我已将其设置为如果池未被使用，该生物会将其所有元素放入池中并开始查看。如果他们找不到所需的一切，他们应该将他们拥有的所有 Artifact 放入池中，将池设置为不忙，然后向池中等待的一个生物发出信号他们也准备好通过它了。

我的问题是，如果一个生物正在看水池，而另一个生物在等待，它找不到它喜欢的东西，它会在不通知或不让另一个生物通过它的情况下重复该过程。

我的尝试:我最初尝试使用锁，但锁不会向其他线程发出信号。然后我利用同步 ( Party ) 重写了它。然后我认为这是因为线程在某处崩溃，但线程可以一直运行，甚至在作业完成后将其项目转储回池中(假设生物没有将池锁定在边缘)。

boolean ready = target.hasReqArtifacts( reqStones, reqPotions, reqWands, reqWeapons );
    //checks to see if creature already has correct amount of each item.
    //If it does it should skip pool interaction until it dumps its used items
    //back into the pool.
    System.out.println( "Ready: " + ready );
    while ( !ready ) {//begin pool interaction
        synchronized ( target.poolParty ){
            System.out.println( "Ready: " + ready );
            System.out.println( this );
            while ( target.poolParty.busyPool ) {//busyPool is initialized false
                startJob.setEnabled( false );
                try {
                    target.poolParty.wait();
                } catch ( InterruptedException e ) {}
            }
            synchronized ( target.poolParty ) {
                target.poolParty.busyPool = true;
                target.poolParty.notifyAll();//notify all threads that they need to wait because this one will proceed
            }
        }
        target.releaseArtifacts();// adds all artifacts held by creature to an arraylist in poolParty
                                  //then clears the creatures inventory
        target.pickUpArtifacts( reqStones, reqPotions, reqWands, reqWeapons );

        ready = target.hasReqArtifacts( reqStones, reqPotions, reqWands, reqWeapons );
        if ( ready ) {
            synchronized ( target.poolParty ) {
                System.out.println( "has required Items" );
                target.poolParty.busyPool = false;
                target.poolParty.notify();
            }
        } else {
            synchronized ( target.poolParty ) {
                System.out.println( "Does not has required Items" );
                target.poolParty.busyPool = false;
                target.releaseArtifacts();
                target.poolParty.notifyAll();
                try {
                    Thread.sleep( 1000 );
                } catch ( InterruptedException e ){}
            }
        }
    }//end pool interaction

我在一个生物有多个工作但一次只能做一个工作的场景中执行这种线程之间的交互并且它完美地工作。我定制了这些方法来适应这种情况，但我仍然遇到问题。

注意:我对并发还很陌生，所以如果我的词汇量没有达到这个主题的水平，请原谅我。

Answer 1

看起来您正睡在一个使用 target.poolParty 进行同步的 block 中。这意味着等待访问池的其他线程将无法访问它，因为该线程正在阻塞它。将 sleep() 移到该 block 之外。

在另一个地方，您在已经使用它进行同步的 block 中使用 synchronized (target.poolParty)。这是不必要的(好吧，整个代码块是不必要的，我删除了它。只是指出)。 wait() 和 notify*() 也是低级同步原语，很少需要。

boolean ready = target.hasReqArtifacts( reqStones, reqPotions, reqWands, reqWeapons );
//checks to see if creature already has correct amount of each item.
//If it does it should skip pool interaction until it dumps its used items
//back into the pool.
System.out.println( "Ready: " + ready );
while ( !ready ) {
    // begin pool interaction
    synchronized (target.poolParty) {
        target.pickUpArtifacts( reqStones, reqPotions, reqWands, reqWeapons );
        ready = target.hasReqArtifacts( reqStones, reqPotions, reqWands, reqWeapons );

        /* I'd move this here. If we never release out items then the
           other party members can't use them while this one still does
           not have the needed items. Now they will be available to
           other parties while this thread sleeps. */
        if (!ready) {
            // adds all artifacts held by creature to an arraylist in poolParty
            target.releaseArtifacts();
        }
    }

    // These don't access the pool, so they can be outside the synchronized block
    if ( ready ) {
        System.out.println( "has required Items" );
    } else {
        System.out.println( "Does not have required Items" );
        // Sleep before the next try to get the required items. Lets other
        // threads attempt to fetch their needed items
        try {
            Thread.sleep( 1000 );
        } catch ( InterruptedException e ) {
            // Added, because silently eating exceptions is a bad idea
            e.printStackTrace();
        }
    }
}//end pool interaction