Java并发编程入门（八）线程生命周期

时间 2019-11-07

标签 java 并发编程入门线程生命周期栏目 Java 繁體版

原文原文链接

Java极客 | 做者 / 铿然一叶这是Java极客的第 36 篇原创文章

1、线程生命周期一

线程生命周期以下：java

1.线程建立后状态为NEW 2.线程启动后状态从NEW变为RUNNABLE 3.线程调用同步代码块未得到同步锁时状态为BLOCK，若是获取到锁则状态为RUNNABLE 4.线程运行结束后状态为TERMINATED

验证代码以下：编程

public class LifeCycleDemo {

    public static void main(String[] args) {
        Thread t0 = new Thread(new Runnable() {
            public void run() {
                Counter.increase();
            }
        });

        Thread t1 = new Thread(new Runnable() {
            public void run() {
                Counter.increase();
            }
        });

        //建立后状态为NEW
        printState(t0);
        printState(t1);

        t0.start();
        t1.start();

        //启动后状态为RUNNABLE
        printState(t0);
        printState(t1);

        sleep(1000);

        //运行后t0得到同步锁，进入代码块执行Thread.sleep后状态变为TIMED_WAITING，t1等待获取同步锁，状态为BLOCKED
        printState(t0);
        printState(t1);

        sleep(4000);

        //线程执行完后状态为TERMINATED
        printState(t0);
        printState(t1);

        System.out.println("count: " + Counter.getCount());
    }

    private static void printState(Thread t) {
        System.out.println(t.getName() + " " + t.getState());
    }

    private static void sleep(long millis) {
        try {
            Thread.sleep(millis);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class Counter {
    private static int count;

    public synchronized static void increase() {
        count = count +1;

        try {
            //模拟并发争用
            Thread.sleep(2000);
        } catch (InterruptedException ie) {
            ie.printStackTrace();
        }
    }

    public static int getCount() {
        return count;
    }
}
复制代码

打印日志：缓存

Thread-0 NEW
Thread-1 NEW
Thread-0 RUNNABLE
Thread-1 RUNNABLE
Thread-0 BLOCKED
Thread-1 TIMED_WAITING
Thread-0 TERMINATED
Thread-1 TERMINATED
count: 2
复制代码

2、线程生命周期二

验证代码以下：安全

public class LifeCycleDemo2 {
    public static void main(String[] args) {
        Thread t0 = new Thread(new ChildThread(Thread.currentThread()));

        t0.start();
        //子线程启动后状态为RUNNABLE
        printState(t0);

        try {
            //子线程join后，主线程状态为WAITING
            t0.join();

            //主线程状态为RUNNABLE
            printState(Thread.currentThread());

            //子线程运行结束，状态为TERMINATED
            printState(t0);

        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private static void printState(Thread t) {
        System.out.println(t.getName() + " " + t.getState());
    }
}

class ChildThread implements Runnable {

    Thread parentThread;

    public ChildThread(Thread parentThread) {
        this.parentThread = parentThread;
    }
    public void run() {
        try {
            Thread.sleep(2000);
            //这里是在子线程join以后打印，此时主线程状态为WAITING
            System.out.println(parentThread.getName() + " " + parentThread.getState());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
复制代码

输出日志：bash

Thread-0 RUNNABLE
main WAITING
main RUNNABLE
Thread-0 TERMINATED
复制代码

其余场景不在单独列出代码。并发

3、线程生命周期三

这里和前面的区别是方法参数中增长了时间参数，再也不举例验证。

end.post

Java极客站点： javageektour.com/this