Java Day 14

多线程--线程间通信
 对同一个资源进行处理，但是任务却不同

线程间通信--等待唤醒机制
 1、wait();   线程处于冻结状态，被wait线程存储在线程池中
 2、notify(); 从线程池唤醒一个线程
 3、notifyAll(); 唤醒所有线程
 方法必须定义在同步中

 为什么操作线程的方法wait notify notifyAll定义在Object类中
  因为这些方法是监视器的方法，监视器其实就是锁
  锁可以是任意的对象，任意的对象调用的方式一定是定义在Object类中

唤醒--代码优化

多生产者多消费者
 
多生产多消费者问题解决
 notifyAll();
 
 while判断标记，解决了线程获取执行权后是否重新运行
 
 notifyAll()解决了本方线程一定唤醒对方线程
 

多生产多消费问题 JDK1.5新特性 -- Lock
 同步代码块，对于锁的操作是隐式的。
 

import java.util.concurrent.locks.*;
//import java.util.condition;
class Resource{
    private String name;
    private int count = 1;
    private boolean  flag = false;
    Lock lock = new ReentrantLock();
    //Condition c1 = lock.newCondition();
    Condition pro_con = lock.newCondition();
    Condition cos_con = lock.newCondition();
    
    Resource(){}
    
    public void set(String name){//synchronized
        lock.lock();
        try{
            while(flag)//while(flag)--死锁
                //try{wait();}catch(InterruptedException e){}
                try{pro_con.await();}catch(InterruptedException e){}
            this.name = name + count;
            count++;
            System.out.println(Thread.currentThread().getName()+": 生产..5.0.  "+this.name);
            flag = true;
            //notifyAll();//notifyAll()
            //c1.signalAll();//notifyAll()
            cos_con.signal();//notifyAll()
        }
        finally{
            lock.unlock();
        }
        
        
    }
    
    public  void out(){ //synchronized
        lock.lock();
        try{
            while(!flag)//while(flag)--出现死锁--notifyAll()
                try{cos_con.await();}catch(InterruptedException e){}
            System.out.println(Thread.currentThread().getName()+":...消费了......"+name);
            flag = false;
            //notifyAll();//notifyAll()}
            //c1.signalAll();
            pro_con.signal();
            
        }
        finally{
            lock.unlock();//notifyAll()
        }    
    }
}

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();
        }    
    }
}

class ProduceConsumerDemo{
    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();
        
    }
}

 将同步和锁封装成了对象

JDK1.5新特性--condition
 wait notify notifyAll

JDK1.5解决方法
 一个锁多个监视器

范例
 Lock 接口：替代了同步代码块或同步函数，由隐式锁操作变成显示
  lock()   获取锁
  unlock() 释放锁 在finally代码块中

 Condition 接口 替代了Object中的wait notify notifyAll方法，单独进行封装
  await
  signal
  signalAll

 class BoundedBuffer {
   final Lock lock = new ReentrantLock();
   final Condition notFull  = lock.newCondition(); 
   final Condition notEmpty = lock.newCondition(); 

   final Object[] items = new Object[100];
   int putptr, takeptr, count;

   public void put(Object x) throws InterruptedException {
     lock.lock();
     try {
       while (count == items.length)
         notFull.await();
       items[putptr] = x;
       if (++putptr == items.length) putptr = 0;
       ++count;
       notEmpty.signal();
     } finally {
       lock.unlock();
     }
   }

   public Object take() throws InterruptedException {
     lock.lock();
     try {
       while (count == 0)
         notEmpty.await();
       Object x = items[takeptr];
       if (++takeptr == items.length) takeptr = 0;
       --count;
       notFull.signal();
       return x;
     } finally {
       lock.unlock();
     }
   }
 }

wait sleep 区别
 1、wait可以指定时间也可以不指定，sleep必须指定
 2、在同步中，对cpu的执行权和锁的处理不同
    wait 释放执行权和锁
    sleep 释放执行权 不是释放锁

停止线程方式--定义标记
 1、stop方法
 2、run方法结束
 怎么控制线程的任务结束呢？
  控制循环就可以结束任务

停止线程方式--Interrupt
 如果线程处于冻结状态，无法读取标记，如何结束？
 interrupt 将线程从冻结强制恢复成运行状态，但会发生中断异常

守护进程--setDaemon
 后台线程，先于线程启动前调用

join方法
 setPriority(Thread.MAX_PRIORITY)
 
 yield