3、线程--线程调度

1、线程的优先级

Thread类提供了获取和设置线程优先级的方法
getPriority：获取当前线程的优先级
setPriority：设置当前线程的优先级
Java语言为线程类设置了10个优先级，分别使用1~10内的整数表示 ，整数值越大代表优先级越高。

每个线程都有一个默认的优先级，主线程的默认优先级是5。

Thread类定义的三个常量分别代表了几个常用的优先级：
MAX_PRIORITY:：代表了最高优先级10
MIN_PRIORITY:：代表了最低优先级1
NORM_PRIORITY:：代表了正常优先级5

setPriority 不一定起作用，在不同的操作系统、不同的 JVM 上，效果也可能不同。

　　操作系统也不能保证设置了优先级的线程就一定会先运行或得到更多的CPU时间。
　　在实际使用中，不建议使用该方法

public class testYXJ extends Thread{
    @Override
    public void run() {
        for(int i = 0 ; i< 10;i++){
            System.out.println(Thread.currentThread().getName() +
                    "---" + i);
            
        }
    }
    
    public static void main(String[] args) {
        Thread t1 = new testYXJ();
        Thread t2 = new testYXJ();
        
        //查看线程的优先级
        System.out.println(t1.getPriority());//5
        System.out.println(t2.getPriority());//5
        
        //设置线程优先级
        t1.setPriority(MAX_PRIORITY);
        t2.setPriority(MIN_PRIORITY);
        
        t1.start();
        t2.start();
    }
}

2、线程睡眠：Thread.sleep(long millis)方法，使线程转到阻塞状态。

　　millis参数设定睡眠的时间，以毫秒为单位。当睡眠结束后，就转为就绪（Runnable）状态。

　　sleep()平台移植性好。

public class test implements Runnable{
    @Override
    public void run() {
        for(int i =0;i < 100;i++){
            
            System.out.println(Thread.currentThread().getName() +
                    "--" + i);
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
    }

此时就会两秒进行一个打印输出操作！
 
3、线程等待：Object类中的wait()方法，导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 唤醒方法。

　　这个两个唤醒方法也是Object类中的方法，行为等价于调用 wait(0) 一样。

wait和sleep方法的区别：

1. 他们都是在多线程的环境下，都可以在程序的调用处阻塞指定的毫秒数，并返回。
2. wait()和sleep()都可以通过interrupt()方法 打断线程的暂停状态 

从而使线程立刻抛出InterruptedException。
如果线程A希望立即结束线程B，则可以对线程B对应的Thread实例调用interrupt方法。

如果此刻线程B正在wait/sleep /join，则线程B会立刻抛出InterruptedException

在catch() {} 中直接return即可安全地结束线程。
 需要注意的是，InterruptedException是线程自己从内部抛出的

并不是interrupt()方法抛出的。对某一线程调用 interrupt()时

如果该线程正在执行普通的代码，那么该线程根本就不会抛出InterruptedException。

但是，一旦该线程进入到 wait()/sleep()/join()后，就会立刻抛出InterruptedException 。

不同点：

1. Thread类的方法：sleep(),yield()等
   Object的方法：wait()和notify()等
2. 每个对象都有一个锁来控制同步访问。Synchronized关键字可以和对象的锁交互，来实现线程的同步。
   sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。
3. wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用
　　所以sleep()和wait()方法的最大区别是：
　　　　sleep()睡眠时，保持对象锁，仍然占有该锁；
　　　　而wait()睡眠时，释放对象锁。
　　但是wait()和sleep()都可以通过interrupt()方法打断线程的暂停状态，从而使线程立刻抛出InterruptedException（但不建议使用该方法）。

实例地址：

https://www.cnblogs.com/Mrchengs/p/10807015.html

下方还有实例！
 
4、线程让步：Thread.yield() 方法，暂停当前正在执行的线程对象

　　把执行机会让给相同或者更高优先级的线程。

Thread.yield()方法作用是：暂停当前正在执行的线程对象，并执行其他线程。
 yield()应该做的是让当前运行线程回到可运行状态

以允许具有相同优先级的其他线程获得运行机会

因此，使用yield()的目的是让相同优先级的线程之间能适当的轮转执行

但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。

yield()从未导致线程转到等待/睡眠/阻塞状态。

在大多数情况下，yield()将导致线程从运行状态转到可运行状态，但有可能没有效果。

测试

public class MyRunable implements Runnable{
    @Override
    public void run() {
        for(int i =0;i < 20;i++){
            System.out.println(Thread.currentThread().getName() +
                    "--" + i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                
                e.printStackTrace();
            }
        }
    }
    }
}

public class test implements Runnable{
    @Override
    public void run() {
        for(int i =0;i < 10;i++){
            System.out.println(Thread.currentThread().getName() +
                    "--" + i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //yield()---线程让步
            if(i == 10){
                Thread.yield();
            }
        }
    }
    public static void main(String[] args) {
        test m = new test();
        MyRunable m2 = new MyRunable();
        Thread t1 = new Thread(m);
        Thread t2 = new Thread(m2);
        t1.start();
        t2.start();
    }
}

此时的执行效果如下图：

注意sleep()和yield()方法的区别：

sleep()使当前线程进入停滞状态

所以执行sleep()的线程在指定的时间内肯定不会被执行

yield()只是使当前线程重新回到可执行状态

所以执行yield()的线程有可能在进入到可执行状态后马上又被执行。

sleep 方法使当前运行中的线程睡眼一段时间，进入不可运行状态

这段时间的长短是由程序设定的

yield 方法使当前线程让出 CPU 占有权，但让出的时间是不可设定的。

实际上，yield()方法对应了如下操作：先检测当前是否有相同优先级的线程处于同可运行状态

如有，则把 CPU  的占有权交给此线程，

否则，继续运行原来的线程。

所以yield()方法称为“退让”，它把运行机会让给了同等优先级的其他线程

sleep 方法允许较低优先级的线程获得运行机会

但 yield()  方法执行时，当前线程仍处在可运行状态

所以，不可能让出较低优先级的线程些时获得 CPU 占有权。

在一个运行系统中，如果较高优先级的线程没有调用 sleep 方法

又没有受到 IO 阻塞

那么，较低优先级线程只能等待所有较高优先级的线程运行结束，才有机会运行。 

5、线程加入：join()方法，等待其他线程终止。

　　在当前线程中调用另一个线程的join()方法，则当前线程转入阻塞状态

　　直到另一个进程运行结束，当前线程再由阻塞转为就绪状态。

join是Thread类的一个方法，启动线程后直接调用

即join()的作用是：“等待该线程终止”

这里需要理解的就是该线程是指的主线程等待子线程的终止。

也就是在子线程调用了join()方法后面的代码，只有等到子线程结束了才能执行。

在很多情况下，主线程生成并起动了子线程，如果子线程里要进行大量的耗时的运算

主线程往往将于子线程之前结束，但是如果主线程处理完其他的事务后

需要用到子线程的处理结果，也就是主线程需要等待子线程执行完成之后再结束

这个时候就要用到join()方法了

实例：

不加入join()方法

public class test implements Runnable{
    @Override
    public void run() {
        for(int i =0;i < 10;i++){
            
            System.out.println(Thread.currentThread().getName() +
                    "--" + i);
        }
    }
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName() + "开始");
        test m = new test();
        //MyRunable m2 = new MyRunable();
        Thread t1 = new Thread(m);
        Thread t2 = new Thread(m);
        t1.start();
        t2.start();
        System.out.println(Thread.currentThread().getName() + "结束");
    }
}

此时的执行结果：

主线程比子线程提前结束

使用join()方法：

public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName() + "开始");
        test m = new test();
        //MyRunable m2 = new MyRunable();
        Thread t1 = new Thread(m);
        Thread t2 = new Thread(m);
        t1.start();
        t2.start();
        try {
            t1.join();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        try {
            t2.join();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        System.out.println(Thread.currentThread().getName() + "结束");
    }

此时的结果可以看出

主线程在子线程执行结束之后在结束

 
6、线程唤醒：Object类中的notify()方法，唤醒在此对象监视器上等待的单个线程。

　　如果所有线程都在此对象上等待，则会选择唤醒其中一个线程。

　　选择是任意性的，并在对实现做出决定时发生。线程通过调用其中一个 wait 方法，在对象的监视器上等待。

　　 直到当前的线程放弃此对象上的锁定，才能继续执行被唤醒的线程。

　　被唤醒的线程将以常规方式与在该对象上主动同步的其他所有线程进行竞争；

　　例如，唤醒的线程在作为锁定此对象的下一个线程方面没有可靠的特权或劣势。

　　类似的方法还有一个notifyAll()，唤醒在此对象监视器上等待的所有线程。

Obj.wait()，与Obj.notify()必须要与synchronized(Obj)一起使用

也就是wait,与notify是针对已经获取了Obj锁进行操作

从语法角度来说就是Obj.wait(),Obj.notify必须在synchronized(Obj){...}语句块内。

从功能上来说wait就是说线程在获取对象锁后，主动释放对象锁，同时本线程休眠。

直到有其它线程调用对象的notify()唤醒该线程，才能继续获取对象锁，并继续执行。

相应的notify()就是对对象锁的唤醒操作。

但有一点需要注意的是notify()调用后，并不是马上就释放对象锁的

而是在相应的synchronized(){}语句块执行结束，自动释放锁后

JVM会在wait()对象锁的线程中随机选取一线程，赋予其对象锁，唤醒线程，继续执行。

public class MyRunnable2 implements Runnable{

    private String name;
    private Object prev;
    private Object self;
    
    
    public MyRunnable2(String name, Object prev, Object self) {
        super();
        this.name = name;
        this.prev = prev;
        this.self = self;
    }

    @Override
    public void run() {
        
        int count = 10;   
        while (count > 0) {   
            synchronized (prev) {   
                    synchronized (self) {   
                        System.out.print(name);   
                        count--;  
                        
                        self.notify();   
                    }   
                    try {   
                        prev.wait();   
                    } catch (InterruptedException e) {   
                        e.printStackTrace();   
                    }   
            }  
        }
    }
     public static void main(String[] args) throws Exception {   
            Object a = new Object();   
            Object b = new Object();   
            Object c = new Object();   
            MyRunnable2 pa = new MyRunnable2("A", c, a);   
            MyRunnable2 pb = new MyRunnable2("B", a, b);   
            MyRunnable2 pc = new MyRunnable2("C", b, c);   
               
               
            new Thread(pa).start();
            Thread.sleep(100);  //确保按顺序A、B、C执行
            new Thread(pb).start();
            Thread.sleep(100);  
            new Thread(pc).start();   
            Thread.sleep(100);  
            }   
}

从大的方向上来讲，该问题为三线程间的同步唤醒操作，主要的目的就是ThreadA->ThreadB->ThreadC->ThreadA循环执行三个线程。

为了控制线程执行的顺序，那么就必须要确定唤醒、等待的顺序，所以每一个线程必须同时持有两个对象锁，才能继续执行。

一个对象锁是prev，就是前一个线程所持有的对象锁。还有一个就是自身对象锁。

主要思想：

为了控制执行的顺序，必须要先持有prev锁，也就前一个线程要释放自身对象锁，

再去申请自身对象锁，两者兼备时打印，之后首先调用self.notify()释放自身对象锁，

唤醒下一个等待线程，再调用prev.wait()释放prev对象锁，终止当前线程，等待循环结束后再次被唤醒。

程序运行的主要过程就是A线程最先运行，持有C,A对象锁，后释放A,C锁，唤醒B。线程B等待A锁，再申请B锁，后打印B，再释放B，A锁，唤醒C，线程C等待B锁，再申请C锁，后打印C，再释放C,B锁，唤醒A。

interrupt():

不要以为它是中断某个线程！它只是线线程发送一个中断信号

让线程在无限等待时（如死锁时）能抛出抛出，从而结束线程

但是如果你吃掉了这个异常，那么这个线程还是不会中断的！