多线程系列第（四）篇---线程的优先级以及yeild和join方法

线程的优先级

1.线程的优先级分为1到10，1对应MIN_PRIORITY，10对应MAX_PRIORITY
2.可以通过setPriority方法为线程设置优先级，默认的优先级为5
3.在线程启动前设置线程的优先级
4.优先级高的线程不一定就先执行完，只是在进入运行状态的机会要高于优先级低的线程而已
结论：我们不能指望通过设置线程的优先级来影响线程的执行顺序，而要通过其他方法来制定线程的执行顺序

优先级代码示例

public class PriorityDemo {

class Thread1 extends Thread {

    public Thread1(String name) {
        super(name);
    }

    public void run() {
        int random;
        for (int i = 0; i < 5; i++) {
            random=new Random().nextInt(100);
            System.out.println(getName()+"第"+i+"次获得随机数"+random);
        }
    }
}

class Thread2 extends Thread {

    public Thread2(String name) {
        super(name);
    }

    public void run() {
        int random;
        for (int i = 0; i < 5; i++) {
            random=new Random().nextInt(100);
            System.out.println(getName()+"第"+i+"次获得随机数"+random);
        }
    }
}

public static void main(String[] args) {
    PriorityDemo demo=new PriorityDemo();
    Thread1 t1=demo.new Thread1("线程1");
    Thread1 t2=demo.new Thread1("线程2");
    
    t1.setPriority(Thread.MIN_PRIORITY);
    t2.setPriority(Thread.MAX_PRIORITY);
    
    t1.start();
    t2.start();
    }
}

运行结果
线程1第0次获得随机数18
线程2第0次获得随机数43
线程1第1次获得随机数6
线程2第1次获得随机数6
线程1第2次获得随机数15
线程2第2次获得随机数32
线程1第3次获得随机数16
线程1第4次获得随机数73
线程2第3次获得随机数81
线程2第4次获得随机数11

当然上面只是其中的一种运行结果，列出这个结果主要是想说明，优先级高的不一定就先执行完

yeild

一个调用yield方法的线程，是要告诉虚拟机它乐意让其他线程占用自己的位置，yield将当前线程由运行状态置为就绪状态，来达到让步的目的，但是刚进入就绪状态的线程也可能马上进入运行状态。

yield代码示例

public class YeildDemo {

class Thread1 extends Thread {

    public Thread1(String name) {
        super(name);
    }

    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(getName() + "第" + i + "次执行");
            Thread.yield();
        }
    }
}

class Thread2 extends Thread {

    public Thread2(String name) {
        super(name);
    }

    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(getName() + "第" + i + "次执行");
            Thread.yield();
        }
    }
}

public static void main(String[] args) {
    YeildDemo demo = new YeildDemo();
    Thread1 t1 = demo.new Thread1("线程1");
    Thread1 t2 = demo.new Thread1("线程2");

    t1.start();
    t2.start();
  }
}

上述代码在没有调用yeild方法的输出结果

线程1第0次执行
线程1第1次执行
线程1第2次执行
线程1第3次执行
线程1第4次执行
线程2第0次执行
线程2第1次执行
线程2第2次执行
线程2第3次执行
线程2第4次执行

上述代码在调用yeild方法的输出结果

线程2第0次执行
线程1第0次执行
线程2第1次执行
线程1第1次执行
线程2第2次执行
线程1第2次执行
线程2第3次执行
线程1第3次执行
线程2第4次执行
线程1第4次执行

当然上述结果只是其中的一种运行结果，但经过多次运行，大致就是上面的规律。

join

阻塞当前线程，直到调用join方法的线程执行结束之后，才恢复执行

join代码示例

public class JoinDemo {

class Thread1 extends Thread {

    public Thread1(String name) {
        super(name);
    }

    public void run() {
        for (int i = 0; i < 3; i++) {
            System.out.println(getName() + "第" + i + "次执行");
        }
    }
}

class Thread2 extends Thread {

    public Thread2(String name) {
        super(name);
    }

    public void run() {
        for (int i = 0; i < 3; i++) {
            System.out.println(getName() + "第" + i + "次执行");
        }
    }
}

public static void main(String[] args) {
    System.out.println(Thread.currentThread().getName()+"执行开始");

    
    JoinDemo demo = new JoinDemo();
    Thread1 t1 = demo.new Thread1("线程1");
    Thread1 t2 = demo.new Thread1("线程2");


    t1.start();
    t2.start();
    
    try {
        t1.join();
        t2.join();
    } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

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

}

上述程序在没有调用t1和t2的join方法的运行结果如下

main执行开始
main执行结束
线程1第0次执行
线程1第1次执行
线程1第2次执行
线程2第0次执行
线程2第1次执行
线程2第2次执行

上述程序在在调用了t1和t2的join方法的运行结果如下

main执行开始
线程1第0次执行
线程1第1次执行
线程1第2次执行
线程2第0次执行
线程2第1次执行
线程2第2次执行
main执行结束