多线程_线程间通信

线程间通信：

　　多个线程在处理同一资源，但是他们的任务不同（一部分线程生产鸭子，另一部分线程销售鸭子）

　　从下面的代码开始，一步步的引出问题并解决

public class Text2 {
    public static void main(String[] args) {
    Ziyuan r=new Ziyuan();      //创建资源
    Inp a=new Inp(r);             //创建输入任务
    Outp b=new Outp(r);          //创建输出任务
    Thread t=new Thread(a);        //创建输入线程，执行路径（执行输入任务）
    Thread t1=new Thread(b);    //创建输出线程，执行路径（执行输出任务）
    t.start();       //开启线程
    t1.start();
    }
}
class Ziyuan{
    String name;
    String sex;    
}
class Inp implements Runnable{
    Ziyuan r;
    int a=0;
    Inp(Ziyuan r){
        this.r=r;
    }
    public void run(){
        while(true){
            if(a==0){
                r.name="黑";
                r.sex="男";
            }else{
                r.name="白白";
                r.sex="女女";
            }
            a=(a+1)%2;
        }
    }    
}
class Outp implements Runnable{
    Ziyuan r;
    int a=0;
    Outp(Ziyuan r){
        this.r=r;
    }
    public void run(){
        while(true)
        System.out.println(r.name+"...."+r.sex);
    }
}

输出的结果会出现这种情况：

              黑....女女
　　　　白白....男

会出现这种情况是因为有多个线程操作共享资源，并且操作共享资源的代码有多条，可以用同步解决这种安全问题

修改后的代码为：（就是简单的加上一个锁就可以解决问题，要保证线程使用的是同一个锁）

public class Text2 {
    public static void main(String[] args) {
    Ziyuan r=new Ziyuan();      //创建资源
    Inp a=new Inp(r);             //创建输入任务
    Outp b=new Outp(r);          //创建输出任务
    Thread t=new Thread(a);        //创建输入线程，执行路径（执行输入任务）
    Thread t1=new Thread(b);    //创建输出线程，执行路径（执行输出任务）
    t.start();       //开启线程
    t1.start();
    }
}
class Ziyuan{
    String name;
    String sex;    
}
class Inp implements Runnable{
    Ziyuan r;
    int a=0;
    Inp(Ziyuan r){
        this.r=r;
    }
    public void run(){
              while(true){
                   synchronized(r){
                   if(a==0){
                        r.name="黑";
                        r.sex="男";
                   }else{
                        r.name="白白";
                        r.sex="女女";
                 }
                 a=(a+1)%2;
                 }
              } 
    }    
}
class Outp implements Runnable{
    Ziyuan r;
    int a=0;
    Outp(Ziyuan r){
        this.r=r;
    }
    public void run(){
        while(true)
             synchronized(r){
                 System.out.println(r.name+"...."+r.sex);
             }
    }
}

这样虽然解决了安全问题，但是输入（输出）都是成片存在的，假设我们是在卖票，这样就会出现一张票被重复卖出多次。

现在我就想，输入一个，打印一个。这样就引出了等待唤醒机制。

等待唤醒机制：

　　涉及的方法：

　　　　wait()  让线程进入冻结状态， 把线程存储在线程池中

　　　　notify()  唤醒线程池中的一个线程

　　　　notifyall() 唤醒线程池中所有线程

　　　　这些方法都是操做线程状态的  

　　　　这些方法必须定义在同步中  

　　　　这些方法必须明确属于哪个锁

             因为这些方法是监视器的方法，同步中一把锁只能有一组监视器，锁是任意的对象，任意的对象调用的方式一定定义在Object类，所以这些方法定义在Object类中。（我的理解，锁调用这些方法去改变线程状态，要保证锁一定能调用这些方法，那就只能把这些方法定义在Object中）

public class Text2 {
    public static void main(String[] args) {
    Ziyuan r=new Ziyuan();      //创建资源
    Inp a=new Inp(r);             //创建输入任务
    Outp b=new Outp(r);          //创建输出任务
    Thread t=new Thread(a);        //创建输入线程，执行路径（执行输入任务）
    Thread t1=new Thread(b);    //创建输出线程，执行路径（执行输出任务）
    t.start();       //开启线程
    t1.start();
    }
}
class Ziyuan{
    String name;
    String sex;    
    boolean bool=false;
}
class Inp implements Runnable{
    Ziyuan r;
    int a=0;
    Inp(Ziyuan r){
        this.r=r;
    }
    public void run(){
              while(true){
                   synchronized(r){
                      if(r.bool){
                          try {r.wait();} catch (InterruptedException e) {}
                      }
                   if(a==0){
                        r.name="黑";
                        r.sex="男";
                   }else{
                        r.name="白白";
                        r.sex="女女";
                 }
                 a=(a+1)%2;
                 r.bool=true;
                 r.notify();
                 }
              } 
    }    
}
class Outp implements Runnable{
    Ziyuan r;
    int a=0;
    Outp(Ziyuan r){
        this.r=r;
    }
    public void run(){
        while(true)
             synchronized(r){
                 if(!r.bool){
                          try {r.wait();} catch (InterruptedException e) {}
                      }
                 System.out.println(r.name+"...."+r.sex);
                 r.bool=false;
                 r.notify(); 
             }
    }
}

这样问题便得到了解决

可是我不满足于现在的单线程输入 单线程输出；搞点猛地多线程输入 多线程输出。引出经典操作“多生产者多消费者”

多生产者多消费者：

　　在上面的代码基础上简单的修改成买卖鸭子，并实现多生产者多消费者，看看会出什么问题：

public class Text2 {
    public static void main(String[] args) {
    Ziyuan r=new Ziyuan();      //创建资源
    Inp a=new Inp(r);             //创建输入任务
    Outp b=new Outp(r);          //创建输出任务
    Thread t0=new Thread(a);        //创建输入线程，执行路径（执行输入任务）
    Thread t1=new Thread(a);    //创建输出线程，执行路径（执行输出任务）
    Thread t2=new Thread(b);
    Thread t3=new Thread(b);
    t0.start();       //开启线程
    t1.start();
    t2.start();
    t3.start();
    }
}
class Ziyuan{
    boolean bool=false;
    int a=0;
}
class Inp implements Runnable{
    Ziyuan r;
    Inp(Ziyuan r){
        this.r=r;
    }
    public void run(){
              while(true){
                   synchronized(r){
                      if(r.bool){
                          try {r.wait();} catch (InterruptedException e) {}
                      }
                      r.a++;
                      System.out.println(Thread.currentThread().getName()+"生产鸭子。。。"+r.a);
                 r.bool=true;
                 r.notify();
                 }
              } 
    }    
}
class Outp implements Runnable{
    Ziyuan r;
    Outp(Ziyuan r){
        this.r=r;
    }
    public void run(){
        while(true)
             synchronized(r){
                if(!r.bool){
                          try {r.wait();} catch (InterruptedException e) {}
                      }
                 System.out.println(Thread.currentThread().getName()+"卖出鸭子"+r.a--);
                 r.bool=false;
                 r.notify(); 
             }
    }
}

　　28 47 行使用的是if判断，这就表示如果线程0在生产了鸭子后，冻结在28行处的1线程醒了，那么他不会在判断，而是继续生产鸭子，这就导致错误数据的出现（这时将if换成while）。

　　换成了while后发现，出现了死锁情况（原因：比如.线程1.2.3已经进入了冻结状态，线程0进冻结前，唤醒了t1线程，然后t1获得了CPU的执行权，在t1进行了判断后也进入了冻结状态，这是所有的线程都进入了冻结状态）。

　　只要我们保证一定能够唤醒对方线程，那么就能解决问题，所以使用notifyAll()方法替换notify()方法就可以解决问题。

　　注意：1.if只有一次判断，会导致不该运行的线程运行　　2.while判断标记，解决了线程获得执行权之后是否要运行的问题，如果while和notify一起使用会导致死锁　　3.notifyAll解决了一定会唤醒对方线程的问题（如果己方线程总是获得CPU执行权，那么效率会降低）

Lock接口和Condition接口

　　如果只是为了唤醒对方线程，而去唤醒所有线程，很明显是不明智的，所以在JDK1.5版本后为我们提供了解决方法

　　Lock:  lock()获取锁　　unlock()释放锁　　ReentrantLock（已知实现子类）　　Lock代替了synchronized方法和语句的使用

　　Condition: await()冻结线程　　signal()唤醒一个线程　　signalAll()唤醒所有线程　　Condition代替了Objcet监视器方法的使用

　　同步中，一把锁只能有一组监视器，但是Lock锁已有多组Condition监视器

　　

　　如果线程发生了异常，那么锁将无法释放，所以unlock()一定要放在finally中

使用升级后的JDK所提供的方法重新写代码，提高效率

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;


public class Text2 {
    public static void main(String[] args) {
        Ziyuan r=new Ziyuan();
        Inp in=new Inp(r);
        Outp out=new Outp(r);
        Thread t0=new Thread(in);
        Thread t1=new Thread(in);
        Thread t2=new Thread(out);
        Thread t3=new Thread(out);
        t0.start();
        t1.start();
        t2.start();
        t3.start();
    
    }
}
class Ziyuan{
    private String name;
    private String sex;
    private boolean bool=false;
    private int mun=1;
    Lock suo=new ReentrantLock();
    Condition inJian=suo.newCondition();
    Condition outJian=suo.newCondition();
    
    void show(String name){
        try{
            suo.lock();
            while(bool){
                try {inJian.await();} catch (InterruptedException e) {}
            }
            this.name=name+mun++;
            System.out.println(Thread.currentThread().getName()+"生产。。。"+this.name);
            bool=true;
            outJian.signal();
        }finally{
            suo.unlock();
        }
        
    }
    void show1(){
        try{
            suo.lock();
            while(!bool){
                try {outJian.await();} catch (InterruptedException e) {}
            }
            System.out.println(Thread.currentThread().getName()+"消费.................."+name);
            bool=false;
            inJian.signal();
        }finally{
            suo.unlock();
        }
        
    }
}
class Inp implements Runnable{
    Ziyuan r;
    Inp(Ziyuan r){
        this.r=r;
    }
    public void run(){
           while(true){
               r.show("烤鸭");
              } 
    }    
}
class Outp implements Runnable{
    Ziyuan r;
    Outp(Ziyuan r){
        this.r=r;
    }
    public void run(){
        while(true){
            r.show1();
        }
    }
}

wait和sleep的区别：

　　1:wait可以指定时间，也可以不指定

　　　sleep一定要指定时间

　　2:wait释放执行权，释放锁

　　　sleep释放执行权，不释放锁

停止线程：

　　stop() 过时了，存在安全隐患

　　run() 方法结束（run方法运行完了，该线程会自动结束）（使用标记结束run方法），代码如下：

class Producer implements Runnable
{
    int a=0;
    boolean bool=true; //标记
    public void run()
    {
        while(bool){
            System.out.println(Thread.currentThread().getName()+"          "+a++);
        }
    }
    public void set(boolean bool){   //修改标记，用来控制run()方法的结束
        this.bool=bool;
    }
    
}
class  ProducerConsumerDemo2
{
    public static void main(String[] args) 
    {
        Producer pro = new Producer();
        Thread t0 = new Thread(pro);
        t0.start();
        for(int i=0;i<500;i++){
            System.out.println(Thread.currentThread().getName()+".................."+i);
            if(i==499){
                pro.set(false);
            }
            
        }
        System.out.println(Thread.currentThread().getName()+"..................................."+"over");
    }
}

如果线程处于冻结状态，那么利用标记来结束线程是行不通的；所以，Thread提供了interrupt()方法强制唤醒线程（因此会抛异常）

class Producer implements Runnable
{
    int a=0;
    boolean bool=true; //标记
    public synchronized void run()
    {
        while(bool){
            try {
                wait();
            } 
            catch (InterruptedException e) {
                bool=false;  //因为这中唤醒机制会发生InterruptedException异常，一定会运行catch 所以一般吧标记写在catch中
            }
            System.out.println(Thread.currentThread().getName()+"          "+a++);
        }
    }    
}
class  ProducerConsumerDemo2
{
    public static void main(String[] args) 
    {
        Producer pro = new Producer();
        Thread t0 = new Thread(pro);
        t0.start();
        for(int i=0;i<500;i++){
            System.out.println(Thread.currentThread().getName()+".................."+i);
            if(i==499){
                t0.interrupt();
            }
            
        }
        System.out.println(Thread.currentThread().getName()+"..................................."+"over");
    }
}

守护线程（后台线程）：

　　steDaemon(boolean)    (当参数为true的时候这个线程为守护线程)  

　　　　　　　　　　  　　后台和前台线程基本一样，唯一不同的就是，当前台线程全部运行结束后，后台线程也会跟着结束。（当正在运行的程序全都为守护线程的时候，JAVA虚拟机会自动退出）

　其他方法：

　　　join()　一般临时加入一个线程执行运算，会调用这个方法（假设有t0 t1 main三个线程，如果t0调用了这个方法，那么主线程会冻结，t0 t1抢夺CPU的执行权，当t0运算完成，main才接触冻结状态）

　　　setPriority(int)  设置线程的优先级（1-10）一般分为三个等级（1-5-10）注意并不是设置成了10这个最高级，这个线程就会拼命运行，只不过是CPU比较照顾一点。