黑马程序员系列第二篇 多线程（2）

（前言：本篇文章主要依据毕向东老师的课程视频整理而成，如要详细学习，请观看毕老师视频  百度网盘链接地址：http://pan.baidu.com/s/1i3m6DrJ）

目录：1、线程通信--生产消费者示例（线程通信安全、等待唤醒机制）    2、停止线程、及其会出现的问题、及解决的办法    3、守护线程及几个Thread的方法                   4、工作中线程的常见写法

1、线程通信--生产消费者示例

代码示例：

public class ProducerConsumer {
//需求：生产和消费行为依次进行。     设置产品为BMW   设置生产者和消费者线程各两个
    public static void main(String[] args) {
        
         Product pro=new Product();
         
        new Thread(new Producter(pro)).start();       
        new Thread(new Consumer(pro)).start();
        new Thread(new Producter(pro)).start();
        new Thread(new Consumer(pro)).start();

    }
}
class Product{
    
    private String name;
    private int No=1;
    boolean flag=false;
    
    public synchronized void set(String names){
        while(flag)
            try {
                 this.wait();//等待状态                
            } catch (InterruptedException e) {
                e.printStackTrace();
            }    
              this.name=names+"---"+this.No++;
              System.out.println(this.name+"---被"+Thread.currentThread().getName()+"生产");            
                flag=true;
                this.notifyAll();//唤醒所有线程
    }    
    public synchronized void out(){
        while(!flag)
            try {
                this.wait();//等待状态
            } catch (InterruptedException e) {
                e.printStackTrace();
            }        
        System.out.println(this.name+"---被"+Thread.currentThread().getName()+"消费了-------");        
               flag=false;
               this.notifyAll();//唤醒所有线程
    }
}
//生产者
class Producter implements Runnable{
    private Product p;
    public Producter(Product pr){
        this.p=pr;
    }
    public void run(){        
      while(true){
        p.set("BMW");
      }
    }    
}
//消费者
class Consumer implements Runnable{
    private Product p;
    public Consumer(Product pr){
        this.p=pr;
    }    
    public void run(){        
        while(true){
        p.out();
        }
    }
}

使用JDK5.0新特性改进后的代码

/*JDK5.0后增加了Lock 和Condition新类特性来取代 同步和锁的繁琐操作 */
public class ProducerConsumerNew {

    public static void main(String[] args) {
        
        Product pro=new Product();
        
       new Thread(new Producter(pro)).start();       
       new Thread(new Consumer(pro)).start();
       new Thread(new Producter(pro)).start();
       new Thread(new Consumer(pro)).start();
         
    }

}
class ProductNew{    
    private String name;
    private int No=1;
    boolean flag=false;
    
    private Lock lock=new ReentrantLock();
    private Condition con1=lock.newCondition();
    private Condition con2=lock.newCondition();
    
    public  void set(String name){
        
        while(flag)
            try {
                lock.lock();
                con1.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally{
                lock.unlock();
            }
          this.name=name+"---"+this.No++;  
          System.out.println(this.name+"---被"+Thread.currentThread().getName()+"生产");
            
          this.flag=true;
          con2.signal();
    }
    
    public  void out(){        
        while(!this.flag)
            try {
                lock.lock();
                con2.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally{
                lock.unlock();
                con1.signal();
            }        
        System.out.println(this.name+"---被"+Thread.currentThread().getName()+"消费了-------");
        
        this.flag=false;
    }
}
//生产者
class ProducterNew implements Runnable{
    private ProductNew p;
    public ProducterNew(ProductNew pr){
        this.p=pr;
    }
    public void run(){
      while(true){
        p.set("BMW");
      }
    }    
}
//消费者
class ConsumerNew implements Runnable{
    private ProductNew p;
    public ConsumerNew(ProductNew pr){
        this.p=pr;
    }    
    public void run(){
        while(true)
        p.out();
    }
}

  

2、停止线程、及其会出现的问题、及解决的办法    

停止线程思路：开启多线程运行，运行代码通常是循环结构，只要控制住循环，就可以让run()方法结束，线程即结束。

特殊情况：当线程处于冻结状态（wait（）），就不会读取到标记，那么线程就不会结束。

解决办法：当没有指定的方式让冻结的线程恢复到运行状态时，需要用Interrupt（）方法强制清除冻结状态，再用操作标记让线程结束 

 

一个简单的代码例子

public class ThreadStop {

    public static void main(String[] args) {
        
        ThreadTt tt=new ThreadTt();
        
        Thread th1=new Thread(tt);
        Thread th2=new Thread(tt);
        th1.start();
        th2.start();
        int count=0;
        while(true){
            if(++count>60){     //循环来控制线程的结束
                th1.interrupt();  //强制清除线程冻结状态
                th2.interrupt();
                break;
            }
            System.out.println(Thread.currentThread().getName()+"....run---"+count);
        }      
        System.out.println(Thread.currentThread().getName()+"....over");
    }
}
class ThreadTt implements Runnable{
    
   boolean flag=true;
   Lock lock=new ReentrantLock();
   Condition con=lock.newCondition();
    public synchronized void run() {
        
        while(flag){
            try {
                wait();       //用这个方法让线程处于冻结状态
            } catch (InterruptedException e) {
                System.out.println(e.getStackTrace());
                 flag=false;
            }
        System.out.println(Thread.currentThread().getName()+"...run");
        }
    }
}

 

3、守护线程及几个Thread的方法

守护线程/用户线程：通俗而言为”后台进程”，当前台进程都结束时，后台进程自动结束；当正在运行的线程都是守护线程时，JVM自动退出。     

 

setDaemon()方法设置守护线程，该方法必须在启动线程前调用

 

 

Join()方法  特点：当A线程执行到了B线程的jion（）方法是，A就会等待，等B线程都执行完以后，A才会执行。Jion可以用来临时加入线程执行    线程抢夺cpu执行权

 

ToString（）方法

 

setPriority（）方法 更改线程的优先级，优先级代表抢夺资源的频率高低

 

Yield（）方法  暂停当前线程的执行，去执行其它线程

 

4、工作中线程的常见写法（用到内部类）

不多说，看代码

public class ThreadStand {

    public static void main(String[] args) {
     //工作中多线程的常见写法，构建内部类
        new Thread(){
            public void run(){
                for(int i=0;i<100;i++)
                    System.out.println(Thread.currentThread().getName()+"....run...."+i);
            }
        }.start();
        
        for(int i=0;i<100;i++)
            System.out.println(Thread.currentThread().getName()+"....run...."+i);
        
        //构造内部类
        Runnable rn= new Runnable(){
            public void run() {
                for(int i=0;i<100;i++)
                    System.out.println(Thread.currentThread().getName()+"....run...."+i);                
            }
        };  
        new Thread(rn).start();   
    }
}

       

       初学者难免错误，欢迎评判指教，持续更正ing...........