java编程中的多线程实现同步

要理解notify()和wait(),因为这两个方法不属于Thread 类,而是属于最底层的object基础类的,也就是说不光是Thread，每个对象都有notify和wait的功能
为什么？因为他们是用来操纵锁的, 而每个对象都有锁,锁是每个对象的基础,既然锁是基础的,那么操纵锁的方法当然也是最基础了.

 

每一个对象除了有一个锁之外，还有一个等待队列（wait set），当一个对象刚创建的时候，它的对待队列是空的。

我们应该在当前线程锁住对象的锁后，去调用该对象的wait方法。

Wait和notify方法只能在同步方法和同步块中调用,必须是同一个对象

当调用对象的notify方法时，将从该对象的等待队列中删除一个任意选择的线程，这个线程将再次成为可运行的线程。

当调用对象的notifyAll方法时，将从该对象的等待队列中删除所有等待的线程，这些线程将成为可运行的线程。

按照Think in Java中的解释:"wait()允许我们将线程置入"睡眠"状态，同时又"积极"地等待条件发生改变.
而且只有在一个notify()或notifyAll()发生变化的时候，线程才会被唤醒，并检查条件是否有变."

我们来解释一下这句话.

"wait()允许我们将线程置入"睡眠"状态",也就是说,wait也是让当前线程阻塞的,这一点和sleep或者suspend是相同的.那和sleep,suspend有什么区别呢?

区别在于"(wait)同时又"积极"地等待条件发生改变",这一点很关键,sleep和suspend无法做到.
因为我们有时候需要通过同步 （synchronized）的帮助来防止线程之间的冲突，而一旦使用同步,就要锁定对象，也就是获取对象锁,其它要使用该对象锁的线程都只能排队等着, 等到同步方法或者同步块里的程序全部运行完才有机会.
在同步方法和同步块中,无论sleep()还是suspend()都不可能自己被调用的时候解除锁定,他们都霸占着正在使用的对象锁不放.

而wait却可以,它可以让同步方法或者同步块暂时放弃对象锁,而将它暂时让给其它需要对象锁的人(这里应该是程序块,或线程)用,这意味着可在执行wait()期间调用线程对象中的其他同步方法!
在其它情况下(sleep啊,suspend啊),这是不可能的.
但是注意我前面说的,只是暂时放弃对象锁,暂时给其它线程使用,我wait所在的线程还是要把这个对象锁收回来的呀.wait什么?就是wait别人用完了还给我啊！

好,那怎么把对象锁收回来呢?
第一种方法,限定借出去的时间.在wait()中设置参数,比如wait(1000),以毫秒为单位,就表明我只借出去1秒中,一秒钟之后,我自动收回.（前提是其他线程释放了该锁，否则时间超时了也收不回来的）。
第二种方法,让借出去的人通知我,他用完了,要还给我了.这时,我马上就收回来.哎,假如我设了1小时之后收回,别人只用了半小时就完了,那怎么办呢?*!当然用完了就收回了,还管我设的是多长时间啊.

那么别人怎么通知我呢?相信大家都可以想到了,notify(),这就是最后一句话"而且只有在一个notify()或notifyAll()发生变化的时候，线程才会被唤醒"的意思了.
因此,我们可将一个wait()和notify()置入任何同步方法或同步块内部，无论在那个类里是否准备进行涉及线程的处理。而且实际上,我们也只能在同步方法或者同步块里面调用wait()和notify().

synchronized (obj){...}；的意思是定义一个同步块,使用obj作为资源锁。obj.wait();的意思是临时释放锁，并阻塞当前线程,好让其他使用同一把锁的线程有机会执行,
在这里假设要用同一把锁的就是thread1线程.thread1线程在执行到一定地方后用obj.notify()通知wait的线程,obj锁已经用完,待notify()所在的同步块运行完之后,wait所在的线程就可以继续执行.

 

class Main {

    public static void main(String[] args) {
        Queue q = new Queue();
        Producer p = new Producer(q);
        Consumer c = new Consumer(q);
        p.start();
        c.start();
    }
}

class Producer extends Thread {

    Queue q;

    Producer(Queue q) {
        this.q = q;
    }

    public void run() {
     synchronized(q){
         for (int i = 0; i < 10; i++) {
             q.put(i);
         }
     }
    }
}

class Consumer extends Thread {

    Queue q;

    Consumer(Queue q) {
        this.q = q;
    }

    public void run() {
        while (true) {
         synchronized(q){
          System.out.println("Consumer get " + q.get());
         }
        }
    }
}

class Queue {

    int value;
    boolean bFull = false;

    public synchronized void put(int i) {
        if (!bFull) {
            value = i;
            System.out.println("Producer put " + i);
            bFull = true;
            notify();
        }
        try {
            wait();
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    public synchronized int get() {
        if (!bFull) {
            try {
                wait();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        bFull = false;
        notify();
        return value;
    }
}

 

这段程序是在前人基础上改的，在两个线程的run方法里加了对q的同步锁，并把System.out.println("Producer put " + i);
这句移到了put（）方法里面，这样打印出来的顺序才是完全正确的