Java基础---第十二天 多线程

一、线程间的通信

三、线程间通信-等待唤醒机制
    1、wait(),notify(),notifyAll(),都使用在同步中，因为要对持有监视器（锁）的线程操作。所以要使用在同步中，因为只有同步才具有锁。
    2、为什么这些操作线程的方法要定义Object类中呢？因为这些方法在操作同步中，线程，都必须要表示它们所操作线程只有的锁，只有同一个锁上的被等待线程，可以被同一个锁上notify唤醒，不可以对不同锁中的线程进行唤醒。也就是说，等待和唤醒必须是同一个锁。
    3、而锁可以是任意对象，所以可以被任意对象调用的方法定义Object类中。

 /*
 线程间通讯：
 其实就是多个线程在操作同一个资源，
 但是操作的动作不同。
 */
 import java.lang.*;
 class Res{
     String name;
     String sex;
     boolean flag = false;
 }
 class Input implements Runnable{
     private Res r;
     Input(Res r){
         this.r = r;
     }
     public void run(){
         int x = 0;
         while(true){
             synchronized(r){
                 if(r.flag){
                     try{ r.wait();}catch(Exception e){}
                 }
                 if(x==0){
                     r.name = "mike";
                     r.sex = "man";
                 }else{
                     r.name = "丽丽";
                     r.sex = "女女女女女";
                 }
                 x = (x+1)%2;
                 r.flag = true;
                 r.notify();
             }
         }
     }
 }
 class Output implements Runnable{
     private Res r;
     Output(Res r){
         this.r = r;
     }
     public void run(){
         while(true){
             synchronized(r){
                 if(!r.flag){
                     try{ r.wait();}catch(Exception e){}
                 }
                 System.out.println(r.name+"    "+r.sex);
                 r.flag = false;
                 r.notify();
             }
         }
     }
 }
 public class Demo{
     public static void main(String args[]){
         Res r = new Res();
         Input in = new Input(r);
         Output out = new Output(r);
         Thread t1 = new Thread(in);
         Thread t2 = new Thread(out);
         t1.start();
         t2.start();
     }
 }

四、线程间通信-代码优化

 class Res{
     private String name;
     private String sex;
     private boolean flag = false;
     public synchronized void set(String name,String sex){
         if(this.flag){
             try{ this.wait();}catch(Exception e){}
         }
         this.name = name;
         this.sex = sex;
         this.flag = true;
         this.notify();
     }
     public synchronized void out(){
         if(!this.flag){
             try{ this.wait();}catch(Exception e){}
         }
         System.out.println(this.name+"    "+this.sex);
         this.flag = false;
         this.notify();
     }
 }
 class Input implements Runnable{
     private Res r;
     Input(Res r){
         this.r = r;
     }
     public void run(){
         int x = 0;
         while(true){
             if(x==0){
                 r.set("mike","man");
             }else{
                 r.set("丽丽","女女女女女");
             }
             x = (x+1)%2;
         }
     }
 }
 class Output implements Runnable{
     private Res r;
     Output(Res r){
         this.r = r;
     }
     public void run(){
         while(true){
             r.out();
         }
     }
 }
 public class Demo{
     public static void main(String args[]){
         Res r = new Res();
         new Thread(new Input(r)).start();
         new Thread(new Output(r)).start();
     }
 }

五、线程间通信-生产者消费者

 class Demo{
     public static void main(String args[]){
         Resource r = new Resource();
         Producer pro = new Producer(r);
         Consumer con = new Consumer(r);
         Thread t1 = new Thread(pro);
         Thread t3 = new Thread(pro);
         Thread t2 = new Thread(con);
         Thread t4 = new Thread(con);
         t1.start();
         t2.start();
         t3.start();
         t4.start();
     }
 }
 class Resource{
     private String name;
     private int count = 1;
     private boolean flag = false;

     public synchronized void set(String name){
         while(flag){
             try{
                 this.wait();
             }catch(Exception e){

             }
         }
         this.name = name+"--"+count++;
         System.out.println(Thread.currentThread().getName()+"...生产者..."+this.name);
         flag = true;
         this.notifyAll();
     }
     public synchronized void out(){
         while(!flag){
             try{
                 this.wait();
             }catch(Exception e){

             }
         }
         System.out.println(Thread.currentThread().getName()+"...消费者..........."+this.name);
         flag = false;
         this.notifyAll();
     }
 }
 class Producer implements Runnable{
     private Resource res;
     Producer(Resource res){
         this.res = res;
     }
     public void run(){
         while(true){
             res.set("+商品+");
         }
     }
 }
 class Consumer implements Runnable{
     private Resource res;
     Consumer(Resource res){
         this.res = res;
     }
     public void run(){
         while(true){
             res.out();
         }
     }
 }

六、线程间通信-生产者消费者JDK5.0升级版
    1、jdk1.5中，提供了，许多县城升级解决方案，将同步 synchrozed 替换成 显示 Lock 操作
    将 object 中的 wait ,notify,notifyAll,替换成了condition 对象。
    该对象可以 Lock锁，进行获取
    2、该实例中，实现了，本方置换型对方的操作。

 import java.util.concurrent.locks.*;
 class Demo{
     public static void main(String args[]){
         Resource r = new Resource();
         Producer pro = new Producer(r);
         Consumer con = new Consumer(r);
         Thread t1 = new Thread(pro);
         Thread t3 = new Thread(pro);
         Thread t2 = new Thread(con);
         Thread t4 = new Thread(con);
         t1.start();
         t2.start();
         t3.start();
         t4.start();
     }
 }
 class Resource{
     private String name;
     private int count = 1;
     private boolean flag = false;
     private Lock lock = new ReentrantLock();
     private Condition condition_pro = lock.newCondition();
     private Condition condition_con = lock.newCondition();
     public void set(String name) throws InterruptedException{
         lock.lock();
         try{
             while(flag){
                 condition_pro.await();
             }
             this.name = name+"--"+count++;
             System.out.println(Thread.currentThread().getName()+"...生产者..."+this.name);
             flag = true;
             condition_con.signal();
         }finally{
             lock.unlock();
         }
     }
     public void out() throws InterruptedException{
         lock.lock();
         try{
             while(!flag){
                 condition_con.await();
             }
             System.out.println(Thread.currentThread().getName()+"...消费者..........."+this.name);
             flag = false;
             condition_pro.signal();
         }finally{
             lock.unlock();
         }
     }
 }
 class Producer implements Runnable{
     private Resource res;
     Producer(Resource res){
         this.res = res;
     }
     public void run(){
         while(true){
             try{
                 res.set("+商品+");
             }catch(InterruptedException e){

             }
         }
     }
 }
 class Consumer implements Runnable{
     private Resource res;
     Consumer(Resource res){
         this.res = res;
     }
     public void run(){
         while(true){
             try{
                 res.out();
             }catch(InterruptedException e){

             }
         }
     }
 }

七、停止线程
    stop方法已经过时。
    如何停止线程？
    只有一种，run()方法结束
    开启多线程运行，运行代码通常是循环结构。
    只要控制住循环，就可以让run方法结束，也就是线程结束
    
    当线程处于冻结状态，就不会读取到标记，那么线程就不会结束
    当没有指定的方式让冻结的线程恢复到运行状态时，这时需要对冻结进行清除。
    强制让线程恢复到运行状态中来，这样就可以操作标记让线程结束
    Thread类提供该方法，  interrupt();

 class Demo{
     public static void main(String args[]){
         StopThread st = new StopThread();
         Thread t1 = new Thread(st);
         Thread t2 = new Thread(st);
         t1.start();
         t2.start();
         int num = 0;
         while(true){
             if(num++ == 60){
                 st.changeFlag();
                 t1.interrupt();
                 t2.interrupt();
                 break;
             }
             System.out.println(Thread.currentThread().getName()+num);
         }
     }
 }
 class StopThread implements Runnable{
     private boolean flag = true;
     public void run(){
         while(flag){
             System.out.println(Thread.currentThread().getName()+"....run");
         }
     }
     public void changeFlag(){
         flag = false;
     }
 }

八、守护线程
    对象.setDemo(true)  如果主线程结束，则这个线程自动结束
九、Join方法
    抢夺主线程行权，注意，只抢夺主线程
    临时加入线程
    当a线程执行到了b线程的 .join() 方法时，a就会等待，等b线程都执行完，a才会执行

 class Demo{
     public static void main(String args[]) throws Exception{
         StopThread st = new StopThread();
         Thread t1 = new Thread(st);
         Thread t2 = new Thread(st);
         t1.start();
         t1.join();
         t2.start();
         t2.join();
         for(int x=0;x<70;x++){
             System.out.println(Thread.currentThread().getName()+"    "+x);
         }
         System.out.println("over");
     }
 }
 class StopThread implements Runnable{
     public void run(){
         for(int x=0;x<70;x++){
             System.out.println(Thread.currentThread().getName()+"    "+x);
         }
     }
 }

10、Byield方法  礼让

    setPriority  设置优先级