多线程1.50的特性

jdk1.5以后将同步和锁封装成了对象。
并将操作锁的隐式方法定义到了该对象中。
将隐式动作变成了显示动作

//创建一个锁对象
Lock lock=new ReentrantLock();  

//通过已有的锁获取该锁上的监视器对象
Condition con=lock.newCondition();

一个锁上面可以挂多个监听器对象。比如。我们可以在lock这个锁上面，挂一个生产者的监听器和挂一个消费者的监听器。
这样做的，可以避免，我们在做生产者消费者的问题，产生的小问题。
小问题指的notifyAll把所以的线程都唤醒的问题。因为这个也会唤醒本方的线程，产生效率低。

    class Resource{
    private String name;
    private int count=1;
    private boolean flag=false; 
    //创建一个锁对象
    Lock lock=new ReentrantLock();  

    //通过已有的锁获取该锁上的监视器对象
    //Condition con=lock.newCondition();


    //通过已有的锁获取两组监视器，一组监视生产者，一组监视消费者
    Condition producer_con=lock.newCondition();
    Condition consumer_con=lock.newCondition();

    public  void set(String name){
        lock.lock(); //获取锁
        try{
            while(flag){
                try {
            //      this.wait();//唤醒的线程在这里开始运行
                    producer_con.await();//生产者的锁进行唤醒
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            this.name=name+count;
            count++;
            System.out.println(Thread.currentThread().getName()+"..生产者5.0.."+this.name);
            flag=true;
//          notifyAll();
//          con.signalAll();
            consumer_con.signal();//唤醒消费者其中的一个线程
        }finally{
            lock.unlock();//释放锁
        }

    }
    public  void out(){
        lock.lock();
        try{
            while(!flag){
                try {
//                  this.wait();
                    consumer_con.await();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName()+"..消费者5.0......."+this.name);
            flag=false;
//          notifyAll();
//          con.signalAll();
            producer_con.signal();
        }finally{
            lock.unlock();
        }

    }
}

class Producer implements Runnable{
    private Resource r;
    Producer(Resource r){
        this.r=r;
    }

    public void run() {
        while(true){
            r.set("烤鸭");
        }

    }


}



class Consumer implements Runnable{
    private Resource r;
    Consumer(Resource r){
        this.r=r;
    }

    public void run() {
        while(true){
            r.out();
        }

    }
}


public class Thread30_1 {
    public static void main(String[] args) {
        Resource r=new Resource();
        Producer pro=new Producer(r);
        Consumer con=new Consumer(r);

        Thread t0=new Thread(pro);
        Thread t1=new Thread(pro);
        Thread t2=new Thread(con);
        Thread t3=new Thread(con);
        t0.start();
        t1.start();
        t2.start();
        t3.start();
    }
}

Lock接口:出现代替了同步代码块或者同步函数。将同步的隐式锁操作变成现实锁的操作。
同时更为灵活。可以一个锁上加上多组监视器。
Lock():获取锁。
unlock():释放锁，通常需要定义finally代码中。

Condition接口:出现替代了Object中的wait() notify() notifyAll()方法。
将这些监视方法单独进行了封装，变成了Condition监视器对象。

await();
signal();
signalAll();