Java多线程编程-生产者，消费者

来个生产者消费者的事例。

说明：利用Object的wait(),notify()或者notifyAll()进行生产者和消费者的同步。

（1）几个同步方法的说明：

   wait()会释放CPU和对象锁，notify()用来唤醒因为使用了wait（）方法而等待的线程（等待同一对象的线程）。而sleep(time)只会释放CPU而不会释放对向锁

（2）Lock和synchronized区别：

    synchronized是基于JVM的，Lock是JDK1.5以后用代码实现的。在并发量不是很大的情况下，优先使用synchronized。但是一旦并发量很大的时候，synchronized会效率低下，这时就得使用Lock，此时Lock的效率会高出很多。
    Lock在synchronized的基础上添加了超时等待锁，打断等待锁的机制。超时等待锁就是一个等待锁的线程在等待了一定的时间后，将不会等待而去执行其它事情。而synchronized等待锁的时候是不会被打断的。
    synchronized是使用悲观所机制，即线程会使用阻塞的方式等待锁，线程阻塞会保持线程的上下文，大量的阻塞会降低CPU效率。而Lock是使用乐观所机制。它不会真正的阻塞，而是不断的尝试获取锁，直到成功获取锁。是使用compareAndSet()方法，是使用CPU的内部指令。所以高并发的情况下，Lock效率会更高。

public class Main {
    public static Object oj=new Object();
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Thread pro=new Thread(new Producer());
        pro.start();
        Thread com=new Thread(new Comsumer());
        com.start();
    }
}


//生产者
class Producer implements Runnable{
    @Override
    public void run() {
        int count=0;
        while(count<5){
            synchronized (Main.oj) {
                System.out.println("生产者"+count);
                count++;
                Main.oj.notify();
                try {
                    Main.oj.wait();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }
}

//消费者
class Comsumer implements Runnable{
    @Override
    public void run() {
        int count=0;
        while(count<5){
            synchronized (Main.oj) {
                System.out.println("消费者"+count);
                count++;
                Main.oj.notify();
                try {
                    Main.oj.wait();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }
}

执行结果;