java多线程join/priority/yield

调用t1.join()的线程释放资源进入等待队列，t1获得资源，执行结束后释放资源,调用者重新获取cpu继续执行;
join()方法是用wait()方法实现的；

public class TestJoin {
    public static void main(String args[]){
        MyThread1 t1 = new MyThread1("abc");
        t1.start();
        try {
            t1.join();
        }catch (InterruptedException e){}
        for (int i=1;i<=10;i++){
            System.out.println("I am main thread");
        }
    }
}
class MyThread1 extends Thread{
    MyThread1(String s){
        super(s);
    }
    public void run(){
        for (int i =1;i<=10;i++){
            System.out.println("I am "+getName());
            try{
                sleep(1000);
            }catch (InterruptedException e){
                return;
            }
        }

    }
}

Priority
MAX_PRIORITY = 10最大
MIN_PRIORITY = 1最小
NORM_PRIORITY = 5；默认
优先级越高，越有可能被先运行

public class TestPriority {
    public static void main(String args[]){
        Thread t1 = new Thread(new T1());
        Thread t2 = new Thread(new T2());
        t1.setPriority(Thread.NORM_PRIORITY+3);
        t1.start();
        t2.start();
    }
}
class T1 implements Runnable{
    public void run(){
        for (int i=0;i<=100;i++){
            System.out.println("T1:"+i);
        }
    }
}
class T2 implements Runnable{
    public void run(){
        for (int i=0;i<=100;i++){
            System.out.println("=========T2:"+i);
        }
    }
}

yield
T1让出位置，给T2执行，T2执行结束T1再执行；
调用yield方法并不会让线程进入阻塞状态，而是让线程重回就绪状态，它只需要等待重新获取CPU执行时间；

public class TestYield1 {
    public static void main(String args[]){
        MyThread2 T1 = new MyThread2("T1");
        MyThread2 T2 = new MyThread2("T2");
        T1.start();
        T2.start();
    }
}
class MyThread2 extends Thread{
    MyThread2(String s){
        super(s);
    }
    public void run(){
        for (int i=0;i<=100;i++){
            System.out.println(getName()+":"+i);
            if (i%10==0){
                yield();
            }
        }
    }
}