java两个线程间隔递增打印数字 （synchronized wait notify的使用）

Question

如下代码

package liupeng.cn.Algorithm.thread;

import java.util.concurrent.Semaphore;
import java.util.concurrent.atomic.AtomicInteger;



public class ThreadTest {
    public static int counter  = 0;
    public static Integer lock = 0;;
    public static void main(String ... arg){
        final Semaphore sp = new Semaphore(2);
        Thread t1 = new Thread(){
            public void run(){
                for(int i=0;i<10;i++){
                    synchronized (lock) {
                        try {
                            while(lock%2==0){
                                lock.wait();
                            }
                            System.out.println("1 "+lock);
                            lock+=1;
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        lock.notify();
                    }
                }
                
            }
        };
        Thread t2 = new Thread(){
            public void run(){
                for(int i=0;i<10;i++){
                    synchronized (lock) {
                        try {
                            while(lock%2==1){
                                lock.wait();
                            }
                            System.out.println("2 "+lock);
                            lock+=1;
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        lock.notify();
                    }
                }
            }
        };
        t1.start();
        t2.start();
        
    }
}

输出报错，求教为什么会这样，感觉没有地方错啊！！！

2 0
Exception in thread "Thread-1" java.lang.IllegalMonitorStateException
    at java.lang.Object.notify(Native Method)
    at liupeng.cn.Algorithm.thread.ThreadTest$2.run(ThreadTest.java:45)

Answer 1

public class ThreadTest {
    public static int counter  = 0;
    public static Integer lock = 0;;
    public static void main(String ... arg){
        Thread t1 = new Thread(){
            public void run(){
                for(int i=0;i<10;i++){
                    synchronized (lock) {
                          lock.notify();
                        try {
                           System.out.println("thread" + Thread.currentThread().getId() +  " print " + i);
                           lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                       
                    }
                }
                
            }
        };
        Thread t2 = new Thread(){
            public void run(){
                for(int i=0;i<10;i++){
                    synchronized (lock) {
                        lock.notify();
                        try {
                            System.out.println("thread" + Thread.currentThread().getId() +  " print " + i);
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        };
        t1.start();
        t2.start();
        
    }
}

你在lock对象上面上锁，但是你居然修改lock的值。

你的代码为报错原因是：

This method（notify/wait） should only be called by a thread that is the owner of this object's monitor.

hread t1 = new Thread(){
            public void run(){
                for(int i=0;i<10;i++){
                    synchronized (lock) {//获取lock=0的对象的监视器
                        try {
                            while(lock%2==0){
                                lock.wait();
                            }
                            System.out.println("1 "+lock);
                            lock+=1;//你居然修改了这个对象
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        lock.notify();//此时lock的值不为0了，但是该线程拥有的是lock=0的对象监视器，这个时候调用notify方法就报错了，因为notify必须使用线程拥有的监视器对应对象调用。
                    }
                }
                
            }
        };