对java 多线程 wait notify notifyAll 的理解

3个人玩游戏一台手柄游戏，一次只能有一个人玩示例代码1

public class Player implements Runnable {
    private final int id;
    private Game game;

    public Player(int id, Game game) {
        this.id = id;
        this.game = game;
    }

    public String toString() {
        return "Athlete<" + id + ">";
    }

    public int hashCode() {
        return new Integer(id).hashCode();
    }

    public void playGame() throws InterruptedException{
        System.out.println(this.toString() + " ready!");
        game.play(this);
    }

    public void run() {
        try {
            playGame();
        } catch (InterruptedException e) {
            System.out.println(this + " quit the game");
        }
    }
}

public class Game implements Runnable {
    private boolean start = false;

    public void play(Player player) throws InterruptedException {
        synchronized (this) {
        System.out.println(player.toString()+"获得锁");
            while (!start){
            System.out.println(player.toString()+"在等待");
            wait();
            System.out.println( player.toString()+"被唤醒了");
            }

            if (start)
                System.out.println(player + " have played!");
        }
    }

    //通知所有玩家
    public synchronized void beginStart() {
        start = true;
        notifyAll();
    }

    public void run() {
        start = false;
        System.out.println("Ready......");
        System.out.println("Ready......");
        System.out.println("game start");
        beginStart();//通知所有玩家游戏准备好了
    }

    public static void main(String[] args) throws InterruptedException {
        Set<Player> players = new HashSet<Player>();
        //实例化一个游戏
        Game game = new Game();

        //实例化3个玩家
        for (int i = 0; i < 3; i++)
            players.add(new Player(i, game));

        //启动3个玩家
        Iterator<Player> iter = players.iterator();
        while (iter.hasNext())
            new Thread(iter.next()).start();
        Thread.sleep(100);

        //游戏启动
        new Thread(game).start();
    }
}

执行结果：
Athlete<0> ready!
Athlete<1> ready!
Athlete<2> ready!
Athlete<0>获得锁
Athlete<0>在等待
Athlete<2>获得锁
Athlete<2>在等待
Athlete<1>获得锁
Athlete<1>在等待
Ready......
Ready......
game start
Athlete<1>被唤醒了
Athlete<1> have played!
Athlete<2>被唤醒了
Athlete<2> have played!
Athlete<0>被唤醒了
Athlete<0> have played!

游戏对象game只有1个，synchronized (this)锁的实际就是game对象，三个玩家线程都依次得到锁并在wait等待时释放锁。启动游戏线程时，通知所有线程，三个玩家线程需要竞争同步锁，得到同步锁的线程执行完synchronized(this)代码块后，自动释放同步锁，处于同步锁阻塞的剩下的2个线程再次竞争，直至都执行完毕。

总结：
wait()会释放锁，下一次被唤醒并获得锁时，会紧接着wait的下一行开始执行。
obj.notifyAll()是唤醒所有在obj上等待的线程，但是notifyAll 不会释放锁，执行完synchronized 代码块时，才会释放锁。（注意：obj.notifyAll()只是唤醒所有在obj上等待的线程，并不会唤醒应用中无关的线程）
notify()是通知一个线程，notifyAll()时通知所有线程，如果上面的例子beginStart方法的notifyAll()改为notify,那么就只有一个人能玩游戏，wait状态的线程如果没被唤醒，会一直的等待，即使锁没被占用。
wait() notify() notifyAll()方法必须写在同步方法或者同步块之内，并且同步的锁必须与调用等待方法和通知方法是同一个对象（比如:synchronized（obj1）{}，那么调用等待方法的也必须是obj1），否则会报java.lang.IllegalMonitorStateException异常，就是因为没有拥有锁导致的。例如上例的beginStart方法，去掉synchronized ，就会报这个错误。

用三个线程打印出连续10次的ABC，要求1个线程打A，1个线程打B，1个线程打C，示例代码：
public class PrintABC {

    public static Boolean isThreadA = true;
    public static Boolean isThreadB = false;
    public static Boolean isThreadC = false;

    public static void main(String[] args) {
        final PrintABC abc = new PrintABC();
        new Thread(new Runnable() {
            public void run() {
                for (int i = 0; i < 10; i++) {
                    synchronized (abc) {
                        while(!isThreadA) {
                            try {
                                abc.wait();
                            } catch (InterruptedException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                            }
                        }
                            System.out.print("A");
                            isThreadA = false;
                            isThreadB = true;
                            isThreadC = false;
                            abc.notifyAll();
                    }
                }
            }
        }).start();

        new Thread(new Runnable() {
            public void run() {
                for (int i = 0; i < 10; i++) {
                    synchronized (abc) {
                        while(!isThreadB) {
                            try {
                                abc.wait();
                            } catch (InterruptedException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                            }
                        }
                            System.out.print("B");
                            isThreadA = false;
                            isThreadB = false;
                            isThreadC = true;
                            abc.notifyAll();
                    }
                }
            }
        }).start();

        new Thread(new Runnable() {
            public void run() {
                for (int i = 0; i < 10; i++) {
                    synchronized (abc) {
                        while(!isThreadC) {
                            try {
                                abc.wait();
                            } catch (InterruptedException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                            }
                        }
                            System.out.print("C");
                            isThreadA = true;
                            isThreadB = false;
                            isThreadC = false;
                            abc.notifyAll();
                    }
                }
            }
        }).start();
    }
}
执行结果：
ABCABCABCABCABCABCABCABCABCABC

abc对象是三个线程共同的锁，存在竞争。for循环中刚好可以使每个字母打印10次，for循环每次都需要竞争abc锁，竞争得到abc锁时，条件不符合则等待并释放锁，让其他线程竞争，条件符合则打印字母，打印完成后，会通知所有的线程，在执行完synchronized 块时，会释放锁。
注意：notifyAll 和wait方法的调用对象是锁，所以写成abc.notifyAll();abc.wait(); 3人玩游戏的那个例子，之所以能不写调用的对象，是因为锁就是this ，不写也是等价。

对java 多线程 wait notify notifyAll 的理解

猜你喜欢