关于线程的一点补充

public class StartDead extends Thread{
    private int i;
    public void run(){
        for(;i<100;i++){
            System.out.println(getName()+" "+i);
        }
    }
    public static void main(String[] args) {
        StartDead sd = new StartDead();
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+" "+i);
            if (i== 20) {
                sd.start();
                System.out.println(sd.isAlive());
            }
            //不要对处于死亡状态的线程调用start（）方法，程序只能对新建状态的线程调用start（）方法
            //，对于新建状态的线程两次调用start（）方法也是错误的，这都会引发IllegalThreadStateException异常
            if (i>20 && !sd.isAlive()) {
                System.out.println("调用死亡线程");
                sd.start();
            }
        }
    }
}

public class JoinThread extends Thread{
    public JoinThread(String name){
        super(name);
    }
    public void run(){
        for (int i = 0; i < 100; i++) {
            System.out.println(getName()+" "+i);
        }
    }
    public static void main(String[] args) throws Exception{
        new JoinThread("新线程").start();
        for (int i = 0; i < 100; i++) {
            if(i==20){
                JoinThread jt = new JoinThread("被Join的线程");
                jt.start();
                //main线程调用了jt线程的join（） 方法，main线程必须等jt执行结束才会向下执行。
                jt.join();
            }
            System.out.println(Thread.currentThread().getName()+" "+i);
        }
    }
}

public class DaemonThread extends Thread{
    public void run(){
        for (int i = 0; i < 100; i++) {
            System.out.println(getName()+" "+i);
        }
    }
    public static void main(String[] args) {
        DaemonThread t = new DaemonThread();
        //将此线程设置成后台线程
        t.setDaemon(true);
        t.start();
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+" "+i);
        }
    }
}

//后台线程：当所有前台线程都死亡，后台线程会自动死亡

//先将t线程设置成后台线程（如果setDaemon(true)在start()方法之后调用会引发IllegalThreadStateException异常）再启动该线程，
//本来该线程应该执行到i等于999才结束，当唯一的前台线程结束后，JVM主动退出
//因而后台线程也就被结束了。

public class PriorityTest extends Thread{
    public PriorityTest(String name){
        super(name);
    }
    public void run(){
        for (int i = 0; i < 100; i++) {
            System.out.println(getName()+" ,其优先级是："+
             getPriority()+",循环变量的值为:"+i);
        }
    }
    public static void main(String[] args) {
        //改变主线程的优先级，这样由主线程创建的子线程优先级默认都是6
        Thread.currentThread().setPriority(6);
        for (int i = 0; i < 30; i++) {
            if (i== 10) {
                PriorityTest low = new PriorityTest("低级");
                low.start();
                System.out.println("创建之初优先级："+low.getPriority());
                //设置该线程为最低优先级
                low.setPriority(Thread.MIN_PRIORITY);
            }
            if (i== 20) {
                PriorityTest high = new PriorityTest("高级");
                high.start();
                System.out.println("创建之初优先级："+high.getPriority());
                //设置该线程为最低优先级
                high.setPriority(Thread.MAX_PRIORITY);
            }
        }
    }
}

//高优先级的线程获得更多的执行机会，所以总是会更早的执行完，或者是更密集的执行