Thread 线程状态--1.1.2

一、线程状态定义

线程状态定义在 java.lang.Thread.State 这个枚举中，一共定义了6总线程状态：

1. New: 尚未启动的线程状态

2. Runnable: 可运行线程的状态，等待CPU调度。（处于这个状态的线程线程不一定正在执行，也有可能是在等待cpu调度）

3. Blocked: 线程阻塞等待监视器锁定的线程状态。处于synchronized 同步代码块或方法中被阻塞。

4. Waiting: 等待线程的线程状态。这些为不带超时的方式： Object.wait、Thread.join、LockSupport.park。

5.Timed Waiting: 具有指定等待时间的等待线程的线程状态。这些为带超时的方式：Thread.sleep、Object.wait、Thread.join、LockSupport.parkNanos、LockSupport.parkUnitl

6.Terminated: 终止线程的线程状态。线程正常执行完成或者出现异常。

二、线程状态之间的切换

下面进行代码演示状态的变更：

1. 线程从新建-> 可运行--> 终止

 1 public class ThreadStateTest {
 2 
 3     public static void main(String[] args) throws InterruptedException {
 4         ThreadStateTest.threadState1();
 5     }
 6 
 7     public static void threadState1() throws InterruptedException {
 8         // 第一种： 线程从 新建---> 运行 ---> 终止
 9         System.out.println("**********第一种线程状态切换：  新建---> 运行 ---> 终止***************");
10         Thread thread1 = new Thread(new Runnable() {
11             public void run() {
12                 System.out.println("thread1当前状态为：" + Thread.currentThread().getState().toString());
13                 System.out.println("thread1执行了");
14             }
15         });
16         // 没有调用start方法时，打印线程状态、
17         System.out.println("没有调用start方法时，thread1的状态为：" + thread1.getState().toString());
18         thread1.start();
19         // 等待2L thread1 执行完毕后打印线程状态
20         Thread.sleep(2000L);
21         System.out.println("thread1执行完毕后线程状态为：" + thread1.getState().toString());
22     }
23 
24 }

View Code

运行结果：

2. 线程从新建---> 可运行---> 等待--> 可运行---> 终止

 1 public class ThreadStateTest {
 2 
 3     public static ThreadStateTest demo = new ThreadStateTest();
 4 
 5     public static void main(String[] args) throws InterruptedException {
 6         ThreadStateTest.threadState2();
 7     }
 8 
 9     public static void threadState2() throws InterruptedException {
10         // 第二种： 线程从 新建---> 可运行----> 等待---> 可运行---> 终止
11         System.out.println("**第二种线程状态切换：   线程从 新建---> 可运行---> 等待--> 可运行--> 终止***");
12         Thread thread2 = new Thread(new Runnable() {
13             public void run() {
14                 synchronized (demo) {
15                     try {
16                         demo.wait();
17                     } catch (InterruptedException e) {
18                         e.printStackTrace();
19                     }
20                 }
21                 try {
22                     Thread.sleep(1000);
23                 } catch (InterruptedException e) {
24                     e.printStackTrace();
25                 }
26                 System.out.println("thread2当前状态为：" + Thread.currentThread().getState().toString());
27                 System.out.println("thread2执行了");
28             }
29         });
30         // 没有调用start方法时，打印线程状态、
31         System.out.println("没有调用start方法时，thread2的状态为：" + thread2.getState().toString());
32         thread2.start();
33         System.out.println("thread2线程状态为：" + thread2.getState().toString());
34         Thread.sleep(500L);
35         System.out.println("thread2线程状态为：" + thread2.getState().toString());
36         synchronized (demo) {
37             demo.notifyAll();
38         }
39         // 等待2L thread2执行完毕后打印线程状态
40         Thread.sleep(2000L);
41         System.out.println("thread2线程状态为：" + thread2.getState().toString());
42     }
43 }

View Code

运行结果：

关于以下代码的疑问：

 1 synchronized (demo) {
 2     try {
 3         demo.wait();
 4     } catch (InterruptedException e) {
 5         e.printStackTrace();
 6     }
 7 }
 8 
 9 synchronized (demo) {
10     demo.notifyAll();
11 }

View Code

请参靠wait方法和notifyAll方法的javaDoc或者参考博客：https://blog.csdn.net/historyasamirror/article/details/6709693

3.线程从新建---> 可运行---> 带超时时间等待--> 可运行---> 终止

 1 public class ThreadStateTest {
 2 
 3     public static ThreadStateTest demo = new ThreadStateTest();
 4 
 5     public static void main(String[] args) throws InterruptedException {
 6         ThreadStateTest.threadState3();
 7     }
 8 
 9     public static void threadState3() throws InterruptedException{
10         //第三种： 线程从 新建---> 可运行----> 带超时时间等待---> 可运行---> 终止
11         System.out.println("**第三种线程状态切换：   线程从 新建---> 可运行---> 带超时时间等待 --> 可运行--> 终止***");
12         Thread thread3 = new Thread(new Runnable() {
13             @Override
14             public void run() {
15                 try {
16                     synchronized (demo){
17                         demo.wait(1000);
18                     }
19                 }catch (InterruptedException e){
20                     e.printStackTrace();
21                 }
22                 System.out.println("thread3当前状态为：" + Thread.currentThread().getState().toString());
23                 System.out.println("thread3执行了");
24             }
25         });
26         // 没有调用start方法时，打印线程状态、
27         System.out.println("没有调用start方法时，thread3的状态为：" + thread3.getState().toString());
28         thread3.start();
29         System.out.println("thread2线程状态为：" + thread3.getState().toString());
30         Thread.sleep(500L);
31         System.out.println("thread2线程状态为：" + thread3.getState().toString());
32         synchronized (demo) {
33             demo.notifyAll();
34         }
35         // 等待2L thread2执行完毕后打印线程状态
36         Thread.sleep(2000L);
37         System.out.println("thread3线程状态为：" + thread3.getState().toString());
38     }
39 }

View Code

运行结果：

**第三种线程状态切换：线程从新建---> 可运行---> 带超时时间等待 --> 可运行--> 终止***
没有调用start方法时，thread2的状态为：NEW
thread2线程状态为：RUNNABLE
thread2线程状态为：TIMED_WAITING
thread2当前状态为：RUNNABLE
thread2执行了
thread2线程状态为：TERMINATED

4.线程从新建---> 可运行---> 阻塞 --> 可运行---> 终止

示例代码：

 1 public class ThreadStateTest {
 2 
 3     public static ThreadStateTest demo = new ThreadStateTest();
 4 
 5     public static void main(String[] args) throws InterruptedException {
 6         ThreadStateTest.threadState4();
 7     }
 8 
 9     public  static void threadState4()  throws InterruptedException{
10         //第四种： 线程从 新建---> 可运行----> 带超时时间等待---> 可运行---> 终止
11         System.out.println("**第四种线程状态切换： 线程从 新建---> 可运行---> 阻塞 --> 可运行--> 终止***");
12         Thread thread4 = new Thread(new Runnable() {
13             @Override
14             public void run() {
15                 synchronized (demo){
16                     System.out.println("thread4当前状态为：" + Thread.currentThread().getState().toString());
17                     System.out.println("thread4执行了");
18                 }
19             }
20         });
21         // 没有调用start方法时，打印线程状态、
22         synchronized (demo){
23             System.out.println("没有调用start方法时，thread4的状态为：" + thread4.getState().toString());
24             thread4.start();
25             System.out.println("thread4线程状态为：" + thread4.getState().toString());
26             //等待2秒，再看thread4的状态
27             Thread.sleep(2000L);
28             System.out.println("thread4线程状态为：" + thread4.getState().toString());
29         }
30         // 等待2S thread4执行完毕后打印线程状态
31         Thread.sleep(2000L);
32         System.out.println("thread4线程状态为：" + thread4.getState().toString());
33     }
34 }

View Code

运行结果：

**第四种线程状态切换：线程从新建---> 可运行---> 阻塞 --> 可运行--> 终止***
没有调用start方法时，thread4的状态为：NEW
thread4线程状态为：RUNNABLE
thread4线程状态为：BLOCKED
thread4当前状态为：RUNNABLE
thread4执行了
thread4线程状态为：TERMINATED

以上就是线程状态的切换的演示内容！

posted @ 2019-01-07 11:01 C_林先森阅读(85) 评论(0) 收藏举报

刷新页面返回顶部

C_林先森

Thread 线程状态--1.1.2

一、 线程状态定义

二、线程状态之间的切换

公告

一、线程状态定义