3、线程的调度

1. 线程睡眠

Thread.sleep(long millis)方法，使线程转到阻塞状态。millis参数设定睡眠的时间，以毫秒为单位。当睡眠结束后，就转为就绪（Runnable）状态。

sleep()使当前线程进入停滞状态，所以执行sleep()的线程在指定的时间内肯定不会执行；

由于sleep()方法是Thread类的方法，因此它不能改变对象的机锁。所以当在一个Synchronized方法中调用sleep（）时，线程虽然休眠了，但是对象的机锁没有被释放，其他线程仍然无法访问这个对象。sleep()方法不需要在同步的代码块中执行。但是sleep()可以通过interrupt()方法打断线程的暂停状态，从而使线程立刻抛出InterruptedException。

2. 线程让步

yield()的作用是让步。它能让当前线程由“运行状态”进入到“就绪状态”，从而让其它具有相同优先级的等待线程获取执行权；但是，并不能保证在当前线程调用yield()之后，其它具有相同优先级的线程就一定能获得执行权；也有可能是当前线程又进入到“运行状态”继续运行！

调用yield方法并不会让线程进入阻塞状态，yield()应该做的是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。

yield()方法对应了如下操作： 先检测当前是否有相同优先级的线程处于同可运行状态，如有，则把 CPU 的占有权交给此线程，否则继续运行原来的线程。所以yield()方法称为”退让”,它把运行机会让给了同等优先级的其他线程。

public class YieldTest {      public static void main(String[] args) throws InterruptedException {          // 创建线程对象          YieldThread t1 = new YieldThread("t1");          YieldThread t2 = new YieldThread("t2");          // 启动线程          t1.start();          t2.start();          // 主线程休眠100毫秒          Thread.sleep(100);          // 终止线程          t1.interrupt();          t2.interrupt();      }  }  class YieldThread extends Thread {      int i = 0;      public YieldThread(String name) {          super(name);      }      public void run() {          while(!isInterrupted()) {              System.out.println(getName() + "执行了" + ++i + "次");              if(i % 10 == 0) {// 当i能对10整除时，则让步                  Thread.yield();              }          }      }  }  

在i%10==0的时候2个线程会重写竞争执行quan

sleep和yield区别

1. sleep()方法会给其他线程运行的机会，而不考虑其他线程的优先级，因此会给较低线程一个运行的机会;yield()方法只会给相同优先级或者更高优先级的线程一个运行的机会。
2. 当线程执行了sleep(long millis)方法后，将转到阻塞状态，参数millis指定睡眠时间;当线程执行了yield()方法后，将转到就绪状态。
3. sleep()方法声明抛出InterruptedException异常，而yield()方法没有声明抛出任何异常
4. sleep()方法比yield()方法具有更好的移植性

3. 线程等待 wait()

wait()方法：当缓冲区已满/空时，生产者/消费者线程停止自己的执行，放弃锁，使自己处于等等状态，让其他线程执行。

notify()方法：当生产者/消费者向缓冲区放入/取出一个产品时，向其他等待的线程发出可执行的通知，同时放弃锁，使自己处于等待状态。

仓库

package com.lf.collection;import java.util.LinkedList;/** * @author LF * @date 2017/11/18 16:38 * @description */public class Storage {    /**     * 仓库最多能存放多少产品     */    private  final int maxNum = 5000;    /**     * 仓库存储的载体     */    private final LinkedList<Object> list =  new LinkedList<Object>();    /**     * 生产产品     */    public void product(int num) {        synchronized (list) {            while (list.size() + num > maxNum) {                System.out.println("【要生产的产品数量】:" + num + "/t【库存量】:"                    + list.size() + "/t暂时不能执行生产任务!");                try {                    list.wait();                } catch (InterruptedException e) {                    e.printStackTrace();                }            }        for (int i = 0; i < num; i++) {            list.add("产品");        }        System.out.println("【已经生产产品数】:" + num + "/t【现仓储量为】:" + list.size());        list.notifyAll();        }    }    public void consume(int num) {        synchronized (list) {            while (list.size() < num) {                System.out.println("【要消费的产品数量】:" + num + "/t【库存量】:"                    + list.size() + "/t暂时不能执行生产任务!");                try {                    list.wait();                } catch (InterruptedException e) {                    e.printStackTrace();                }            }            for (int i = 1; i <= num; ++i) {                list.remove();            }            System.out.println("【已经消费产品数】:" + num + "/t【现仓储量为】:" + list.size());            list.notifyAll();        }    }    public int getMaxNum() {        return maxNum;    }    public LinkedList<Object> getList() {        return list;    }}

生产者

package com.lf.collection;/** * @author LF * @date 2017/11/18 18:52 * @description */public class Produce extends Thread {    private Storage storage;    public Produce(String name, Storage storage) {        this.storage = storage;    }    @Override    public void run() {        while (true) {            storage.product(100);            try {                Thread.sleep(1000);            } catch (InterruptedException e) {                e.printStackTrace();            }        }    }}

消费者

package com.lf.collection;/** * @author LF * @date 2017/11/18 16:22 * @description */public class Consumer extends Thread {    private Storage storage;    public Consumer(String name, Storage storage) {        this.storage = storage;    }    @Override    public void run() {        while (true){        storage.consume(10);            try {                Thread.sleep(1000);            } catch (InterruptedException e) {                e.printStackTrace();            }        }    }}

测试类

package com.lf.collection;/** * @author LF * @description * @date 2017/11/18 19:41 */public class CommunicationTest {    public static void main(String[] args) {        Storage storage = new Storage();        Produce produce = new Produce("生产者", storage);        produce.start();       new Consumer("消费者", storage).start();    }}

4. 线程加入 join()

t.join()方法阻塞调用此方法的线程(calling thread)，直到线程t完成，此线程再继续；通常用于在main()主线程内，等待其它线程完成再结束main()主线程。

public class JoinTest {      public static void main(String[] args) throws InterruptedException {          JoinThread t1 = new JoinThread("t1");          JoinThread t2 = new JoinThread("t2");          t1.start();          t2.start();          t1.join();          t2.join();          System.out.println("主线程开始执行！");      }  }  class JoinThread extends Thread {      public JoinThread(String name) {          super(name);      }      public void run() {          for(int i = 1; i <= 10; i++)              System.out.println(getName() + getId() + "执行了" + i + "次");      }  }  

为什么要用join()方法

为什么要用join()方法在很多情况下，主线程生成并起动了子线程，如果子线程里要进行大量的耗时的运算，主线程往往将于子线程之前结束，但是如果主线程处理完其他的事务后，需要用到子线程的处理结果，也就是主线程需要等待子线程执行完成之后再结束，这个时候就要用到join()方法了。

总结

yield() 与 wait()的比较

我们知道，wait()的作用是让当前线程由“运行状态”进入“等待(阻塞)状态”的同时，也会释放同步锁。而yield()的作用是让步，它也会让当前线程离开“运行状态”。它们的区别是：

• wait()是让线程由“运行状态”进入到“等待(阻塞)状态”，而yield()是让线程由“运行状态”进入到“就绪状态”。
• wait()是会线程释放它所持有对象的同步锁，而yield()方法不会释放锁。