Java线程：线程状态的转换

系统管理员 2024-02-17 21:12 75阅读 0赞

本文转载至：[http://lavasoft.blog.51cto.com/62575/99153][http_lavasoft.blog.51cto.com_62575_99153]

**一. 线程状态类型**  
1. 新建状态（New）：新创建了一个线程对象。  
2. 就绪状态（Runnable）：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权。  
3. 运行状态（Running）：就绪状态的线程获取了CPU，执行程序代码。  
4. 阻塞状态（Blocked）：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：  
（一）、等待阻塞：运行的线程执行wait()方法，JVM会把该线程放入等待池中。  
（二）、同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池中。  
（三）、其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。  
5. 死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。  
**二. 线程状态图**

**![Center][]**

### 下面谈谈如何让线程进入以上几种状态: ###

一、 新建状态（New）：新创建了一个线程对象。

// 线程 NEW 状态
    		 Thread one = new Thread();
    		 System.out.println("thread_one status is:" +
    		 one.getState().toString());

二、 就绪状态（Runnable）：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权。

// 线程RUNNABLE 状态
    		Thread two = new Thread() {
    
    			@Override
    			public void run() {
    				// TODO Auto-generated method stub
    				for (int i = 0; i < 100; i++) {
    					System.out.println("i value is :" + i);
    
    				}
    			}
    
    		};
    		two.start();
    		System.out.println("thread_two status is:" + two.getState().toString());

三、 阻塞状态（Blocked）：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：

**第一种情况：对象锁定阻塞（锁定阻塞）**

final Object obj = new Object();
    
    		Runnable block_one = new Runnable() {
    
    			public void run() {
    				synchronized (obj) {
    					for (int i = 0; i < 1000; i++) {
    						System.out.println("i value is:" + i);
    					}
    				}
    
    			}
    
    		};
    
    		Thread thread_block_one = new Thread(block_one);
    		Thread thread_block_two = new Thread(block_one);
    		thread_block_one.start();
    		thread_block_two.start();
    		System.out.println("thread_block_one status is:"
    				+ thread_block_one.getState().toString());
    		System.out.println("thread_block_two status is:"
    				+ thread_block_two.getState().toString());

**运行截图：**

**![Center 1][]**

第二种：调用Thread.sleep()、Thread.join引发阻塞（其他阻塞）

// 线程TIMED_WAITING 状态 :基于Thread.sleep
    		Runnable block_one = new Runnable() {
    
    			public void run() {
    				for (int i = 0; i < 100; i++) {
    
    					System.out.println("i value is:" + i);
    				}
    			}
    
    		};
    		Runnable block_two = new Runnable() {
    
    			public void run() {
    				for (int i = 0; i < 100; i++) {
    					try {
    						Thread.sleep(100);
    					} catch (InterruptedException e) {
    						// TODO Auto-generated catch block
    						System.out
    								.println("error message is:" + e.getMessage());
    					}
    					System.out.println("i value is:" + i);
    				}
    			}
    
    		};
    		Thread sleep_thread_block_one = new Thread(block_one);
    		Thread sleep_thread_block_two = new Thread(block_two);
    		sleep_thread_block_one.start();
    		sleep_thread_block_two.start();
    		System.out.println("thread_block_one status is:"
    				+ sleep_thread_block_one.getState().toString());
    		System.out.println("thread_block_two status is:"
    				+ sleep_thread_block_two.getState().toString());

// 线程TIMED_WAITING 状态 :基于Thread.join()
    		Runnable block_one = new Runnable() {
    
    			public void run() {
    				for (int i = 0; i < 100; i++) {
    					System.out.println("i value is:" + i);
    				}
    			}
    
    		};
    
    		Runnable block_two = new Runnable() {
    
    			public void run() {
    				for (int i = 0; i < 100; i++) {
    					try {
    						Thread.currentThread().join(1000);
    					} catch (InterruptedException e) {
    						// TODO Auto-generated catch block
    						e.printStackTrace();
    						System.out
    								.println("error message is：" + e.getMessage());
    					}
    
    					System.out.println("i value is:" + i);
    				}
    			}
    
    		};
    
    		Thread sleep_thread_block_one = new Thread(block_one);
    		Thread sleep_thread_block_two = new Thread(block_two);
    		sleep_thread_block_one.start();
    		sleep_thread_block_two.start();
    		System.out.println("thread_block_one status is:"
    				+ sleep_thread_block_one.getState().toString());
    		System.out.println("thread_block_two status is:"
    				+ sleep_thread_block_two.getState().toString());

运行截图：

**![Center 2][]**

**第三种：调用Object.wait(),进入等待阻塞**

final Object lock = new Object();
    		Thread t1 = new Thread() {
    			@Override
    			public void run() {
    
    				for (int i = 0; i < 100; i++) {
    					synchronized (lock) {
    						try {
    							lock.wait();
    						} catch (InterruptedException e) {
    						}
    						System.out.println("t1 value is:" + i);
    					}
    				}
    			}
    		};
    
    		Thread t2 = new Thread() {
    			@Override
    			public void run() {
    
    				for (int j = 0; j < 100; j++) {
    					synchronized (lock) {
    						for (int i = 0; i < 10; i++) {
    							System.out.println(i);
    						}
    						lock.notifyAll();
    					}
    
    				}
    			}
    		};
    
    		t1.setName("one");
    		t2.setName("two");
    
    		t1.start();
    		t2.start();
    		System.out.println("t1 status is:" + t1.getState().toString());
    		System.out.println("t2 status is:" + t2.getState().toString());

运行截图：

**![Center 3][]**

### 总结和完善线程阻塞状态：Thread.sleep()、Thread.join()、Thread.yield()等方法。 ###

1、Thread.sleep(睡眠方法)

Thread.sleep(long millis)和Thread.sleep(long millis, int nanos)静态方法强制当前正在执行的线程休眠（暂停执行），以“减慢线程”。当线程睡眠时，它入睡在某个地方，在苏醒之前不会返回到可运行状态。当睡眠时间到期，则返回到可运行状态。

线程睡眠的原因：线程执行太快，或者需要强制进入下一轮，因为Java规范不保证合理的轮换。

睡眠的实现：调用静态方法。

try \{  
Thread.sleep(123);  
\} catch (InterruptedException e) \{  
e.printStackTrace();  
\}

睡眠的位置：为了让其他线程有机会执行，可以将Thread.sleep()的调用放线程run()之内。这样才能保证该线程执行过程中会睡眠。

注意：

1、线程睡眠是帮助所有线程获得运行机会的最好方法。

2、线程睡眠到期自动苏醒，并返回到可运行状态，不是运行状态。sleep()中指定的时间是线程不会运行的最短时间。因此，sleep()方法不能保证该线程睡眠到期后就开始执行。

3、sleep()是静态方法，只能控制当前正在运行的线程。

2、线程的优先级和线程让步yield()

线程的让步是通过Thread. yield()来实现的。yield()方法的作用是：暂停当前正在执行的线程对象，并执行其他线程。

要理解yield()，必须了解线程的优先级的概念。线程总是存在优先级，优先级范围在1~10之间。JVM线程调度程序是基于优先级的抢先调度机制。在大多数情况下，当前运行的线程优先级将大于或等于线程池中任何线程的优先级。但这仅仅是大多数情况。

注意：当设计多线程应用程序的时候，一定不要依赖于线程的优先级。因为线程调度优先级操作是没有保障的，只能把线程优先级作用作为一种提高程序效率的方法，但是要保证程序不依赖这种操作。

当线程池中线程都具有相同的优先级，调度程序的JVM实现自由选择它喜欢的线程。这时候调度程序的操作有两种可能：一是选择一个线程运行，直到它阻塞或者运行完成为止。二是时间分片，为池内的每个线程提供均等的运行机会。

设置线程的优先级：线程默认的优先级是创建它的执行线程的优先级。可以通过setPriority(int newPriority)更改线程的优先级。例如：

Thread t = new MyThread();  
t.setPriority(8);  
t.start();

线程优先级为1~10之间的正整数，JVM从不会改变一个线程的优先级。然而，1~10之间的值是没有保证的。一些JVM可能不能识别10个不同的值，而将这些优先级进行每两个或多个合并，变成少于10个的优先级，则两个或多个优先级的线程可能被映射为一个优先级。

线程默认优先级是5，Thread类中有三个常量，定义线程优先级范围：

static int MAX\_PRIORITY  
线程可以具有的最高优先级。  
static int MIN\_PRIORITY  
线程可以具有的最低优先级。  
static int NORM\_PRIORITY  
分配给线程的默认优先级。

3、Thread.yield()方法

Thread.yield()方法作用是：暂停当前正在执行的线程对象，并执行其他线程。

yield()应该做的是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。因此，使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。

结论：yield()从未导致线程转到等待/睡眠/阻塞状态。在大多数情况下，yield()将导致线程从运行状态转到可运行状态，但有可能没有效果。

4、join()方法

Thread的非静态方法join()让一个线程B“加入”到另外一个线程A的尾部。在A执行完毕之前，B不能工作。例如：

Thread t = new MyThread();  
t.start();  
t.join();

另外，join()方法还有带超时限制的重载版本。 例如t.join(5000);则让线程等待5000毫秒，如果超过这个时间，则停止等待，变为可运行状态。

线程的加入join()对线程栈导致的结果是线程栈发生了变化，当然这些变化都是瞬时的。下面给示意图：

![Center 4][]

小结

到目前位置，介绍了线程离开运行状态的3种方法：

1、调用Thread.sleep()：使当前线程睡眠至少多少毫秒（尽管它可能在指定的时间之前被中断）。

2、调用Thread.yield()：不能保障太多事情，尽管通常它会让当前运行线程回到可运行性状态，使得有相同优先级的线程有机会执行。

3、调用join()方法：保证当前线程停止执行，直到该线程所加入的线程完成为止。然而，如果它加入的线程没有存活，则当前线程不需要停止。

除了以上三种方式外，还有下面几种特殊情况可能使线程离开运行状态：

1、线程的run()方法完成。

2、在对象上调用wait()方法（不是在线程上调用）。

3、线程不能在对象上获得锁定，它正试图运行该对象的方法代码。

4、线程调度程序可以决定将当前运行状态移动到可运行状态，以便让另一个线程获得运行机会，而不需要任何理由。

[http_lavasoft.blog.51cto.com_62575_99153]: http://lavasoft.blog.51cto.com/62575/99153
[Center]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/29/499e4124b1e4470298a4c5d762485fe0.png
[Center 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/29/233752050c594cf08b330bb7453e95b2.png
[Center 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/29/5edd695f9db946d9b95ef99ed5be6b74.png
[Center 3]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/29/a363ba5420b741168ffd23a0a25ce0cf.png
[Center 4]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/29/dcdb989198864a19b985b9c52a346a07.png