线程之sleep()，wait(),yield(),join()等等的方法的区别

       在上一篇博客中，已经记录了线程与进程区别，以及线程的好处和不足等等，这篇博客中详细的记录下线程中的比较重要的方法，以防止以后忘记。

操作线程的常用方法大体上有sleep(),join(),yield()（让位）,wait(),notify(),notifyAll()，关键字synchronized等等。
 
   由于这些方法功能有些相似，所以有时候会混乱，我们就需要了解它们的具体的原理，以及通过自己写的具体的例子去巩固，加深印象
   
   sleep(),yield()方法的区别：
    
      sleep()和yield()都是Thread类中的静态方法，都会使得当前处于运行状态的线程放弃CPU，但是两者的区别还是有比较大的：
         1：sleep使当前线程（即调用sleep方法的线程暂停一段时间），给其它的线程运行的机会，而且是不考虑其它线程的优先级的，而且不释放资源锁，也就是说如果有synchronized同步块
            ，其它线程仍然是不能访问共享数据的；yeild只会让位给优先级一样或者比它优先级高的线程，而且不能由用户指定暂停多长时间
    
         2：当线程执行了sleep方法之后，线程将转入到睡眠状态，直到时间结束，而执行yield方法，直接转入到就绪状态。这些对线程的生命周期（以后的博客会详细说明）会造成影响的。
   
         3：sleep方法需要抛出或者捕获异常，因为线程在睡眠中可能被打断，而yield方法则没异常。

    测试小程序：

public class Test7 {
    public static void main(String[] args) {
        MyTask4 mt1=new MyTask4();
        MyTask4 mt2=new MyTask4();
        
        Thread t1=new Thread(mt1);
        t1.setName("线程一");
        
        Thread t2=new Thread(mt2);
        t2.setName("线程二");
        
        t1.setPriority(10);
        t2.setPriority(1);
        
        t1.start();
        t2.start();
    }
}

class MyTask4 implements Runnable{

    @Override
    public void run() {
        //取出当前线程
        Thread t=Thread.currentThread();
        if("线程一".equals(t.getName())){
            try {
                //Thread.yield();
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        for (int i = 0; i < 10; i++) {
            System.out.println(t.getName()+":"+i);
        }
    }
    
}

运行结果如下：

   join方法则是用于等待其他线程结束，当前运行的线程可以调用另外一个线程的join()方法，当前的进程状态将转入到挂起状态，知道另外一线程运行结束，该线程才继续运行。
   注意：该方法也要抛出或者捕获异常。
   

        测试小程序：

 /* join方法用于等待其他线程结束
 */
public class Test8 {
    public static void main(String[] args) throws InterruptedException {
        MyTask5 mt=new MyTask5();
        Thread t=new Thread(mt);
        t.setName("新线程");
        System.out.println(t.isAlive());
        t.start();
        System.out.println(t.isAlive());
        t.join();//等待t线程运行完再运行主线程
        System.out.println("主线程");
        System.out.println(t.isAlive());
    }
}
class MyTask5 implements Runnable{

    @Override
    public void run() {
            int i=0;
            while((i++<10)){
                System.out.println(Thread.currentThread().getName()+":"+i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
    }
    

}

运行的结果如下：

   
   synchronized关键字：
       该关键字用于保护共享的数据，当然前提条件是要分清那个数据是共享的数据，每个对象都有一个锁标志，当一个线程访问到该对象，被Synchronized修饰的数据将被"上锁"，阻止其他线程访问。
       当前线程访问完这部分数据后释放锁标志，其他线程就可以访问了。但是如果同步块过多，就相当于单线程了，所以这里要灵活运用。

   wait(),notify(),notifyAll()
   
      这3个方法都是Object类下的方法，而且结合使用。
      这3个方法用于协调多个线程对共享数据的存取，所以必须在synchronized语句块内使用，如果不放在synchronized中，则会报出java.lang.IllegalMonitorStateException异常。
      synchronized关键字用于保护共享数据阻止其他线程对共享数据的存取，但是这样程序的流程就很不灵活了，如何才能在当前线程还没退出synchronized数据块时让其他线程也有机会
      访问共享数据 呢？
      此时就用这三个方法来灵活控制。

      wait() 方法使当前线程暂停执行并释放对象锁标示，释放锁这点非常的重要，让其他线程可以进入synchronized数据块，当前线程被放入对象等待池中。当调用notify()方法后，
      将从对象的等待池中移走一个任意的线程并放到锁标志等待池中，注意
      只有锁标志等待池中线程能够获取锁标志；如果锁标志等待池中没有线程，则 notify()不起作用。
      notifyAll()则从对象等待池中移走所有等待那个对象的线程并放到锁标志等待池中。

      wait() 在其他线程调用此对象的 notify() 方法或者 notifyAll()方法前，导致当前线程等待。
      wait(long timeout)在其他线程调用此对象的notify() 方法 或者 notifyAll()方法，或者超过指定的时间量前，导致当前线程等待。
      wait()后，线程会释放掉它所占有的“锁标志”，从而使线程所在对象中的其他shnchronized数据可被别的线程使用。
      wait()h 和notify()因为会对对象的“锁标志”进行操作，所以他们必需在Synchronized函数或者 synchronized block 中进行调用。如果在non-synchronized 函数
      或 non-synchronized block 中进行调用，虽然能编译通过，但在运行时会发生IllegalMonitorStateException的异常。
   
    测试小程序：
      public class Test6 {
    public static void main(String[] args) {
        Fushikang fushikang=new Fushikang();
        
        Producer p=new Producer(fushikang);
        Producer p2=new Producer(fushikang);
        
        Sale s=new Sale(fushikang);
        Thread t1=new Thread(p);
        Thread t2=new Thread(p2);
        Thread t3=new Thread(s);
        t1.setName("生产一部");
        t2.setName("生产二部");
        t3.setName("销售一部");
        t1.start();
        t2.start();
        t3.start();
        
    }
}

class Producer implements Runnable{
    //生产和消费都是同一资源
    private Fushikang fushikang;
    public Producer(Fushikang fushikang){
        this.fushikang=fushikang;
    }
    @Override
    public void run() {
        for(int i=0;i<10;i++){
            Iphone iphone=new Iphone(i);
            fushikang.product(iphone);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"生产了"+iphone.getId()+"号手机");
        }
    }
    
}

class Sale implements Runnable{
    private Fushikang fushikang;
    
    public Sale(Fushikang fushikang){
        this.fushikang=fushikang;
    }
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            Iphone iphone=fushikang.sale();
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"销售了"+iphone.getId()+"号手机");
        }
    }
    
}

class Fushikang{
    private int index=0;
    private Iphone[] warehouse=new Iphone[10];
    
    public synchronized void product(Iphone iphone){
        //入库iphone到warehouse
        while(index==warehouse.length){
            //让当前的线程停下,直到被sale唤醒
            try {
                this.wait(); //wait方法必须放在synchronized块中
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        this.notifyAll();
        warehouse[index]=iphone;
        index++;
        
    }
    
    public synchronized Iphone sale(){
        while(index==0){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.notifyAll();//唤醒多个
        index--;
        return warehouse[index];
    }
}

class Iphone{
    private int id;
    
    public Iphone(int id){
        this.id=id;
    }
    
    public int getId(){
        return id;
    }
    
    public void setId(int id){
        this.id=id;
    }
}