java基础--23.线程的控制与生命周期

线程的控制(常见方法)

A:休眠线程

static void sleep(long millis) ：在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。

public class ThreadSleep extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + " " + i + new Date());
            try {
                // 休眠 1秒钟
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public static void main(String[] args) {
    ThreadSleep ts1 = new ThreadSleep();
    ThreadSleep ts2 = new ThreadSleep();
    ThreadSleep ts3 = new ThreadSleep();

    ts1.setName("林青霞");
    ts2.setName("林志玲");
    ts3.setName("林志颖");

    ts1.start();
    ts2.start();
    ts3.start();
}

运行结果：

可以看出，3个线程每次休眠1秒，唤醒后3个线程同时执行一次

B:加入线程

public final void join()：等待该线程终止。

public class ThreadJoin extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + " " + i);
        }
    }
}

测试用例：
李渊是李世民和李元霸的爹，所以李渊没出来之前，两兄弟不能出来

public class ThreadJoinDemo {
    public static void main(String[] args) {
        ThreadJoin tj1 = new ThreadJoin(); 
        ThreadJoin tj2 = new ThreadJoin(); 
        ThreadJoin tj3 = new ThreadJoin(); 

        tj1.setName("李渊");
        tj2.setName("李世民");
        tj3.setName("李元霸");

        tj1.start();
        try {
            tj1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        tj2.start();
        tj3.start();
    }

}

运行结果：
最先只有“李渊”线程执行，“李渊”线程执行完之后，线程“李世民”和线程“李元霸”才开始抢占式执行

C:礼让线程

public static void yield()： 暂停当前正在执行的线程对象，并执行其他线程

public class ThreadYield extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + " " + i);
            Thread.yield();
        }
    }
}

public class ThreadYieldDemo {

    public static void main(String[] args) {
        ThreadYield ty1 = new ThreadYield();
        ThreadYield ty2 = new ThreadYield();

        ty1.setName("林青霞");
        ty2.setName("刘毅");

        ty1.start();
        ty2.start();
    }

}

运行结果：
预期是：ty1 ty2 线程交换轮流执行，由于电脑性能的影响，不会是绝对的预期结果。

D:后台线程（守护线程）

public class ThreadDaemon extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + " " + i);
        }
    }
}

测试用例：
我们将主线程认为是“刘备”，ty1 ty2两个线程分别是守护进程，守护“刘备”，当“刘备”执行结束的时候，ty1 ty2两个线程的执行已经没有意义了，这两个线程将会自动停止。

public class ThreadDeamonDemo {
    public static void main(String[] args) {
        ThreadDaemon td1 = new ThreadDaemon();
        ThreadDaemon td2 = new ThreadDaemon();

        td1.setName("关羽");
        td2.setName("张飞");

        //守护主线程的执行，当主线程结束时，守护线程自动结束
        td1.setDaemon(true);
        td2.setDaemon(true);


        td1.start();
        td2.start();

        Thread.currentThread().setName("刘备");
        for(int x=0; x<5; x++){
            System.out.println(Thread.currentThread().getName() + x);
        }
    }
}

运行效果：
当主线程“刘备”结束的时候，其他两个守护线程“张飞”和“关羽”自动结束

E:终止线程

stop() ：终止线程的执行（已过时）
interrupt() ：中断线程执行 用来代替stop() 方法。把线程的状态终止并抛出InterruptedException

public class ThreadStop extends Thread {
    @Override
    public void run() {
        System.out.println("开始执行"+ new Date());

        //休息10秒钟
        try {
            Thread.sleep(10000);
        } catch (Exception e) {
            System.out.println("线程被终止了");
        }

        System.out.println("结束执行"+ new Date());
    }
}

测试用例：
public class ThreadStopDemo {

    public static void main(String[] args) {
        ThreadStop ts = new ThreadStop();
        ts.start();

        //超时3s 直接杀死
        try {
            Thread.sleep(3000);
            ts.interrupt();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

运行结果：
ts线程打算运行10s，但是主线程中计时，当达到3秒的时候，将ts线程终止

线程的生命周期

线程存在5种状态：
A:新建
B:就绪
C:运行
D:阻塞
E:死亡

线程状态转换图：

图中的箭头代表线程的状态可能的转换方向，状态不能逆向！