Java线程-非法监视器状态异常

Question

我正在尝试实现线程，其中一个线程生成随机数，而另一个线程等待，一旦它生成随机数，它应该通知并等待另一个线程也这样做。我收到了非法的监控状态异常，请帮我指出我的错误。

class Dice
{
    int diceValue;

    public Dice()
    {
        this.diceValue=0;
    }
}
public class DiceGame  implements Runnable
{
    Dice d;

public DiceGame()
{
    this.d=new Dice();
}
public void run()
{
    if(Thread.currentThread().getName().equals("Player 1"))
    {
        Random rg=new Random();
        for(int i=0;i<6;i++)
        {
            synchronized(d)
            {

                d.diceValue=rg.nextInt(6);
                System.out.println(Thread.currentThread().getName()+" dice Value is "+d.diceValue);
                d.notifyAll();
                try 
                {
                    d.wait();
                }

                catch (InterruptedException e) 
                {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }
    else if(Thread.currentThread().getName().equals("Player 2"))
    {
        Random rg=new Random();
        for(int i=0;i<6;i++)
        {
            synchronized(d)
            {
                try 
                {
                    d.wait();
                } 
                catch (InterruptedException e) 
                {
                    e.printStackTrace();
                }
                d.diceValue=rg.nextInt(6);
                System.out.println(Thread.currentThread().getName()+"dice Value is ");
                d.notifyAll();
            }
        }
    }
}



public static void main(String []args)
{
    DiceGame dg=new DiceGame();

    Thread tr1=new Thread(dg);
    Thread tr2=new Thread(dg);

    tr1.setName("Player 1");
    tr2.setName("Player 2");

    tr1.start();
    tr2.start();
}
}

Answer 1

您的代码可以通过多种方式进行改进，但是通过一些小技巧，它可以正常工作：

class Dice
{
    int diceValue;

    public Dice()
    {
        this.diceValue=0;
    }
}
public class DiceGame  implements Runnable
{
    Dice d;

    public DiceGame()
    {
        this.d=new Dice();
    }
    @Override
    public void run()
    {
        if(Thread.currentThread().getName().equals("Player 1"))
        {
            final Random rg=new Random();
            for(int i=0;i<6;i++)
            {
                synchronized(d)
                {

                    d.diceValue=rg.nextInt(6);
                    System.out.println(Thread.currentThread().getName()+" dice Value is "+d.diceValue);
                    d.notifyAll();

                    try
                    {
                        d.wait();
                    }

                    catch (final InterruptedException e)
                    {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }
        }
        else if(Thread.currentThread().getName().equals("Player 2"))
        {
            final Random rg=new Random();
            for(int i=0;i<6;i++)
            {
                synchronized(d)
                {
                    try
                    {
                        d.wait();
                    }
                    catch (final InterruptedException e)
                    {
                        e.printStackTrace();
                    }

                    d.diceValue=rg.nextInt(6);

                    System.out.println(Thread.currentThread().getName()+" dice Value is "+d.diceValue);
                    d.notifyAll();
                }
            }
        }
    }



    public static void main(final String []args) throws InterruptedException
    {
        final DiceGame dg=new DiceGame();

        final Thread tr1=new Thread(dg);
        final Thread tr2=new Thread(dg);

        tr1.setName("Player 1");
        tr2.setName("Player 2");

        tr2.start();
        Thread.sleep(100);
        tr1.start();
    }
}

我没有非法Monitorstate异常，但第一个线程被永久锁定。基本上，问题是第一个线程掷骰子，并在第二个线程实际启动并等待骰子之前调用d.notifyAll。这是通过先启动线程2，然后等待一点，再启动线程1来天真地解决的。

您还可以考虑：

• 对大括号 { } 使用 Java 约定
• rg.nextInt 给出的值介于 0..5 之间，而不是 1..6
之间
• 根据线程的名称使线程代码以不同的方式工作是坏主意。在 OOP 中，不同的行为用后代类表示。

我猜你希望有一个通用的解决方案来让多个玩家掷骰子。这个问题不一定是需要并发编程的问题，因为掷骰子是在玩家之间串行进行的。你当然可以让玩家作为线程，但是在任何时间点只有一个线程是活动的。在使用线程的情况下，你应该实现自己的调度逻辑，以确保线程的一个接一个的调度一致。使用监视器（例如synchornize（d））不能提供任何排序保证，它只是为了保证在任何时间点最多有一个线程可以访问骰子而构建的。

具有任意数量玩家但没有线程的解决方案(这毕竟不是并发问题)显示了这种行为:

import java.util.Random;

class Dice {
    private final Random rg=new Random();
    private int diceValue=1;

    public void roll() {
        diceValue=rg.nextInt(6)+1;
    }

    @Override
    public String toString() {
        return "value="+diceValue;
    }
}

public class Player extends Thread {
    Dice dice;
    int rollsLeft=6;

    public Player(final Dice dice) {
        this.dice=dice;
    }

    @Override
    public void run() {
        while (rollsLeft>0) {
            synchronized(dice) {
                // dice obtained
                dice.roll();
                System.out.println(Thread.currentThread().getName()+" rolled "+dice);
            }
            // dice released
            rollsLeft--;

            // just wait a little to make it slower and let other threads to join 
            try {
                Thread.sleep(100);
            } catch (final InterruptedException e) {
                // ignore
            }
        }
    }

    public static void main(final String []args) throws InterruptedException {
        final Dice dice=new Dice();
        final Player player1=new Player(dice);
        final Player player2=new Player(dice);

        player1.start();
        player2.start();
    }
}

这给出了：

Thread-0 rolled value=1
Thread-1 rolled value=6
Thread-0 rolled value=2
Thread-0 rolled value=4
Thread-1 rolled value=2
etc...

如您所见，顺序（即player1、player2、player1和player2）没有保证。

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

class Dice {
    private final Random rg=new Random();
    private int diceValue=1;

    public void roll() {
        diceValue=rg.nextInt(6)+1;
    }

    @Override
    public String toString() {
        return "value="+diceValue;
    }
}

public class Player {
    Dice dice;
    String player;

    public Player(final Dice dice,final String player) {
        this.dice=dice;
        this.player=player;
    }

    public void roll() {
        dice.roll();
        System.out.println(player+" rolled "+dice);
    }

    public static void main(final String []args) throws InterruptedException {
        final Dice dice=new Dice();
        final List<Player> players=new ArrayList<Player>();
        players.add(new Player(dice,"Ann"));
        players.add(new Player(dice,"Ben"));
        players.add(new Player(dice,"Cecil"));
        players.add(new Player(dice,"Denise"));

        for (int rounds=0;rounds<6;rounds++) {
            System.out.println("---");
            for (final Player player:players) {
                player.roll();
            }
        }
    }
}

这会给你预期的输出，即Ann、Ben、Cecil、Denise有6轮掷骰子。

Answer 2

我想，问题是你在等待自己之前通知了所有其他线程。

 d.notifyAll();
 try 
 {
    d.wait();
 }

参考本帖:https://stackoverflow.com/a/828341/5602214

Answer 3

        synchronized(d)
        {
            try 
            {
                d.wait();

每当您看到对wait的无条件调用时，您就知道那里有一个bug。在等待之前，您必须确保等待的事情尚未发生。这就是您输入synchronized块的原因，对吗？

< code > wait /< code > notify 机制的要点是，您可以自动释放锁并等待通知。如果您在调用< code>wait之前不检查谓词(您正在等待的东西)，这是不可能的。

这里，同步块对于在呼叫等待时保持监视器是必要的。

对，因为除非你在一个同步块中，否则你无法判断你正在等待的事情是否已经发生了。而且因为你必须在等待它之前检查它是否已经发生了，所以你只能从一个同步块中调用etc。但是你没有检查！你理解需求，但不了解它的基本原理，所以你正式满足了它，但仍然设法制造了需求旨在防止的问题！