Java线程:线程状态的转换

简介: Java线程:线程状态的转换   一、线程状态   线程的状态转换是线程控制的基础。线程状态总的可分为五大状态:分别是生、死、可运行、运行、等待/阻塞。用一个图来描述如下:   1、新状态:线程对象已经创建,还没有在其上调用start()方法。
Java线程:线程状态的转换
 
一、线程状态
 
线程的状态转换是线程控制的基础。线程状态总的可分为五大状态:分别是生、死、可运行、运行、等待/阻塞。用一个图来描述如下:
 
1、新状态:线程对象已经创建,还没有在其上调用start()方法。
 
2、可运行状态:当线程有资格运行,但调度程序还没有把它选定为运行线程时线程所处的状态。当start()方法调用时,线程首先进入可运行状态。在线程运行之后或者从阻塞、等待或睡眠状态回来后,也返回到可运行状态。
 
3、运行状态:线程调度程序从可运行池中选择一个线程作为当前线程时线程所处的状态。这也是线程进入运行状态的唯一一种方式。
 
4、等待/阻塞/睡眠状态:这是线程有资格运行时它所处的状态。实际上这个三状态组合为一种,其共同点是:线程仍旧是活的,但是当前没有条件运行。换句话说,它是可运行的,但是如果某件事件出现,他可能返回到可运行状态。
 
5、死亡态:当线程的run()方法完成时就认为它死去。这个线程对象也许是活的,但是,它已经不是一个单独执行的线程。线程一旦死亡,就不能复生。 如果在一个死去的线程上调用start()方法,会抛出java.lang.IllegalThreadStateException异常。
 
有关详细状态转换图可以参看本人的“ Java多线程编程总结”中的图
 
二、阻止线程执行
对于线程的阻止,考虑一下三个方面,不考虑IO阻塞的情况:
睡眠;
等待;
因为需要一个对象的锁定而被阻塞。
 
1、睡眠
Thread.sleep(long millis)和Thread.sleep(long millis, int nanos)静态方法强制当前正在执行的线程休眠(暂停执行),以“减慢线程”。当线程睡眠时,它入睡在某个地方,在苏醒之前不会返回到可运行状态。当睡眠时间到期,则返回到可运行状态。
 
线程睡眠的原因:线程执行太快,或者需要强制进入下一轮,因为Java规范不保证合理的轮换。
 
睡眠的实现:调用静态方法。
        try {
            Thread.sleep(123);
        } catch (InterruptedException e) {
            e.printStackTrace();  
        }
 
睡眠的位置:为了让其他线程有机会执行,可以将Thread.sleep()的调用放线程run()之内。这样才能保证该线程执行过程中会睡眠。
 
例如,在前面的例子中,将一个耗时的操作改为睡眠,以减慢线程的执行。可以这么写:
 
    public void run() {
        for(int i = 0;i<5;i++){
// 很耗时的操作,用来减慢线程的执行
//            for(long k= 0; k <100000000;k++);
            try {
                Thread.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();  .
            }

            System.out.println(this.getName()+" :"+i);
        }
    }
 
运行结果:
阿三 :0 
李四 :0 
阿三 :1 
阿三 :2 
阿三 :3 
李四 :1 
李四 :2 
阿三 :4 
李四 :3 
李四 :4 

Process finished with exit code 0
 
这样,线程在每次执行过程中,总会睡眠3毫秒,睡眠了,其他的线程就有机会执行了。
 
注意:
1、线程睡眠是帮助所有线程获得运行机会的最好方法。
2、线程睡眠到期自动苏醒,并返回到可运行状态,不是运行状态。sleep()中指定的时间是线程不会运行的最短时间。因此,sleep()方法不能保证该线程睡眠到期后就开始执行。
3、sleep()是静态方法,只能控制当前正在运行的线程。
 
下面给个例子:
/** 
* 一个计数器,计数到100,在每个数字之间暂停1秒,每隔10个数字输出一个字符串 

* @author leizhimin 2008-9-14 9:53:49 
*/
 
public  class MyThread  extends Thread { 

     public  void run() { 
         for ( int i = 0; i < 100; i++) { 
             if ((i) % 10 == 0) { 
                System.out.println( "-------" + i); 
            } 
            System.out.print(i); 
             try { 
                Thread.sleep(1); 
                System.out.print( "    线程睡眠1毫秒!\n"); 
            }  catch (InterruptedException e) { 
                e.printStackTrace(); 
            } 
        } 
    } 

     public  static  void main(String[] args) { 
         new MyThread().start(); 
    } 
 
-------0 
0    线程睡眠1毫秒! 
1    线程睡眠1毫秒! 
2    线程睡眠1毫秒! 
3    线程睡眠1毫秒! 
4    线程睡眠1毫秒! 
5    线程睡眠1毫秒! 
6    线程睡眠1毫秒! 
7    线程睡眠1毫秒! 
8    线程睡眠1毫秒! 
9    线程睡眠1毫秒! 
-------10 
10    线程睡眠1毫秒! 
11    线程睡眠1毫秒! 
12    线程睡眠1毫秒! 
13    线程睡眠1毫秒! 
14    线程睡眠1毫秒! 
15    线程睡眠1毫秒! 
16    线程睡眠1毫秒! 
17    线程睡眠1毫秒! 
18    线程睡眠1毫秒! 
19    线程睡眠1毫秒! 
-------20 
20    线程睡眠1毫秒! 
21    线程睡眠1毫秒! 
22    线程睡眠1毫秒! 
23    线程睡眠1毫秒! 
24    线程睡眠1毫秒! 
25    线程睡眠1毫秒! 
26    线程睡眠1毫秒! 
27    线程睡眠1毫秒! 
28    线程睡眠1毫秒! 
29    线程睡眠1毫秒! 
-------30 
30    线程睡眠1毫秒! 
31    线程睡眠1毫秒! 
32    线程睡眠1毫秒! 
33    线程睡眠1毫秒! 
34    线程睡眠1毫秒! 
35    线程睡眠1毫秒! 
36    线程睡眠1毫秒! 
37    线程睡眠1毫秒! 
38    线程睡眠1毫秒! 
39    线程睡眠1毫秒! 
-------40 
40    线程睡眠1毫秒! 
41    线程睡眠1毫秒! 
42    线程睡眠1毫秒! 
43    线程睡眠1毫秒! 
44    线程睡眠1毫秒! 
45    线程睡眠1毫秒! 
46    线程睡眠1毫秒! 
47    线程睡眠1毫秒! 
48    线程睡眠1毫秒! 
49    线程睡眠1毫秒! 
-------50 
50    线程睡眠1毫秒! 
51    线程睡眠1毫秒! 
52    线程睡眠1毫秒! 
53    线程睡眠1毫秒! 
54    线程睡眠1毫秒! 
55    线程睡眠1毫秒! 
56    线程睡眠1毫秒! 
57    线程睡眠1毫秒! 
58    线程睡眠1毫秒! 
59    线程睡眠1毫秒! 
-------60 
60    线程睡眠1毫秒! 
61    线程睡眠1毫秒! 
62    线程睡眠1毫秒! 
63    线程睡眠1毫秒! 
64    线程睡眠1毫秒! 
65    线程睡眠1毫秒! 
66    线程睡眠1毫秒! 
67    线程睡眠1毫秒! 
68    线程睡眠1毫秒! 
69    线程睡眠1毫秒! 
-------70 
70    线程睡眠1毫秒! 
71    线程睡眠1毫秒! 
72    线程睡眠1毫秒! 
73    线程睡眠1毫秒! 
74    线程睡眠1毫秒! 
75    线程睡眠1毫秒! 
76    线程睡眠1毫秒! 
77    线程睡眠1毫秒! 
78    线程睡眠1毫秒! 
79    线程睡眠1毫秒! 
-------80 
80    线程睡眠1毫秒! 
81    线程睡眠1毫秒! 
82    线程睡眠1毫秒! 
83    线程睡眠1毫秒! 
84    线程睡眠1毫秒! 
85    线程睡眠1毫秒! 
86    线程睡眠1毫秒! 
87    线程睡眠1毫秒! 
88    线程睡眠1毫秒! 
89    线程睡眠1毫秒! 
-------90 
90    线程睡眠1毫秒! 
91    线程睡眠1毫秒! 
92    线程睡眠1毫秒! 
93    线程睡眠1毫秒! 
94    线程睡眠1毫秒! 
95    线程睡眠1毫秒! 
96    线程睡眠1毫秒! 
97    线程睡眠1毫秒! 
98    线程睡眠1毫秒! 
99    线程睡眠1毫秒! 

Process finished with exit code 0 

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()对线程栈导致的结果是线程栈发生了变化,当然这些变化都是瞬时的。下面给示意图:
 
 
 
小结
到目前位置,介绍了线程离开运行状态的3种方法:
1、调用Thread.sleep():使当前线程睡眠至少多少毫秒(尽管它可能在指定的时间之前被中断)。
2、调用Thread.yield():不能保障太多事情,尽管通常它会让当前运行线程回到可运行性状态,使得有相同优先级的线程有机会执行。
3、调用join()方法:保证当前线程停止执行,直到该线程所加入的线程完成为止。然而,如果它加入的线程没有存活,则当前线程不需要停止。
 
除了以上三种方式外,还有下面几种特殊情况可能使线程离开运行状态:
1、线程的run()方法完成。
2、在对象上调用wait()方法(不是在线程上调用)。
3、线程不能在对象上获得锁定,它正试图运行该对象的方法代码。
4、线程调度程序可以决定将当前运行状态移动到可运行状态,以便让另一个线程获得运行机会,而不需要任何理由。
 
原文链接:http://lavasoft.blog.51cto.com/62575/99153
 
倾城之链 | NICE LINKS DJI Mavic Air
目录
相关文章
|
8天前
|
Java 开发者
Java多线程编程中的常见误区与最佳实践####
本文深入剖析了Java多线程编程中开发者常遇到的几个典型误区,如对`start()`与`run()`方法的混淆使用、忽视线程安全问题、错误处理未同步的共享变量等,并针对这些问题提出了具体的解决方案和最佳实践。通过实例代码对比,直观展示了正确与错误的实现方式,旨在帮助读者构建更加健壮、高效的多线程应用程序。 ####
|
7天前
|
安全 Java 开发者
Java 多线程并发控制:深入理解与实战应用
《Java多线程并发控制:深入理解与实战应用》一书详细解析了Java多线程编程的核心概念、并发控制技术及其实战技巧,适合Java开发者深入学习和实践参考。
|
7天前
|
Java 开发者
Java多线程编程的艺术与实践####
本文深入探讨了Java多线程编程的核心概念、应用场景及实践技巧。不同于传统的技术文档,本文以实战为导向,通过生动的实例和详尽的代码解析,引领读者领略多线程编程的魅力,掌握其在提升应用性能、优化资源利用方面的关键作用。无论你是Java初学者还是有一定经验的开发者,本文都将为你打开多线程编程的新视角。 ####
|
6天前
|
存储 安全 Java
Java多线程编程中的并发容器:深入解析与实战应用####
在本文中,我们将探讨Java多线程编程中的一个核心话题——并发容器。不同于传统单一线程环境下的数据结构,并发容器专为多线程场景设计,确保数据访问的线程安全性和高效性。我们将从基础概念出发,逐步深入到`java.util.concurrent`包下的核心并发容器实现,如`ConcurrentHashMap`、`CopyOnWriteArrayList`以及`BlockingQueue`等,通过实例代码演示其使用方法,并分析它们背后的设计原理与适用场景。无论你是Java并发编程的初学者还是希望深化理解的开发者,本文都将为你提供有价值的见解与实践指导。 --- ####
|
12天前
|
安全 Java 开发者
深入解读JAVA多线程:wait()、notify()、notifyAll()的奥秘
在Java多线程编程中,`wait()`、`notify()`和`notifyAll()`方法是实现线程间通信和同步的关键机制。这些方法定义在`java.lang.Object`类中,每个Java对象都可以作为线程间通信的媒介。本文将详细解析这三个方法的使用方法和最佳实践,帮助开发者更高效地进行多线程编程。 示例代码展示了如何在同步方法中使用这些方法,确保线程安全和高效的通信。
37 9
|
9天前
|
安全 Java 开发者
Java多线程编程中的常见问题与解决方案
本文深入探讨了Java多线程编程中常见的问题,包括线程安全问题、死锁、竞态条件等,并提供了相应的解决策略。文章首先介绍了多线程的基础知识,随后详细分析了每个问题的产生原因和典型场景,最后提出了实用的解决方案,旨在帮助开发者提高多线程程序的稳定性和性能。
|
15天前
|
存储 安全 Java
Java多线程编程的艺术:从基础到实践####
本文深入探讨了Java多线程编程的核心概念、应用场景及其实现方式,旨在帮助开发者理解并掌握多线程编程的基本技能。文章首先概述了多线程的重要性和常见挑战,随后详细介绍了Java中创建和管理线程的两种主要方式:继承Thread类与实现Runnable接口。通过实例代码,本文展示了如何正确启动、运行及同步线程,以及如何处理线程间的通信与协作问题。最后,文章总结了多线程编程的最佳实践,为读者在实际项目中应用多线程技术提供了宝贵的参考。 ####
|
12天前
|
监控 安全 Java
Java中的多线程编程:从入门到实践####
本文将深入浅出地探讨Java多线程编程的核心概念、应用场景及实践技巧。不同于传统的摘要形式,本文将以一个简短的代码示例作为开篇,直接展示多线程的魅力,随后再详细解析其背后的原理与实现方式,旨在帮助读者快速理解并掌握Java多线程编程的基本技能。 ```java // 简单的多线程示例:创建两个线程,分别打印不同的消息 public class SimpleMultithreading { public static void main(String[] args) { Thread thread1 = new Thread(() -> System.out.prin
|
14天前
|
安全 Java
Java多线程集合类
本文介绍了Java中线程安全的问题及解决方案。通过示例代码展示了使用`CopyOnWriteArrayList`、`CopyOnWriteArraySet`和`ConcurrentHashMap`来解决多线程环境下集合操作的线程安全问题。这些类通过不同的机制确保了线程安全,提高了并发性能。
|
15天前
|
Java
java小知识—进程和线程
进程 进程是程序的一次执行过程,是系统运行的基本单位,因此进程是动态的。系统运行一个程序即是一个进程从创建,运行到消亡的过程。简单来说,一个进程就是一个执行中的程序,它在计算机中一个指令接着一个指令地执行着,同时,每个进程还占有某些系统资源如CPU时间,内存空间,文件,文件,输入输出设备的使用权等等。换句话说,当程序在执行时,将会被操作系统载入内存中。 线程 线程,与进程相似,但线程是一个比进程更小的执行单位。一个进程在其执行的过程中产生多个线程。与进程不同的是同类的多个线程共享同一块内存空间和一组系统资源,所以系统在产生一个线程,或是在各个线程之间做切换工作时,负担要比
24 1
下一篇
无影云桌面