Java线程:概念与原理

来源:互联网 发布:1983星星知我心电视剧 编辑:程序博客网 时间:2024/06/16 01:22

这篇文章能帮助大家更具体理解早上培训的内容:

一、操作系统中线程和进程的概念


现在的操作系统是多任务操作系统。多线程是实现多任务的一种方式。

进程是指一个内存中运行的应用程序,每个进程都有自己独立的一块内存空间,一个进程中可以启动多个线程。比如在Windows系统中,一个运行的exe就是一个进程。 

线程是指进程中的一个执行流程,一个进程中可以运行多个线程。比如java.exe进程中可以运行很多线程。线程总是属于某个进程,进程中的多个线程共享进程的内存。同时执行是人的感觉,在线程之间实际上轮换执行。

二、Java中的线程

Java中,线程指两件不同的事情:
1
java.lang.Thread类的一个实例;

2、线程的执行。

使用java.lang.Thread类或者java.lang.Runnable接口或者通过Executor编写代码来定义、实例化和启动新线程。


一个Thread类实例只是一个对象,像Java中的任何其他对象一样,具有变量和方法,生死于堆上。 

Java中,每个线程都有一个调用栈,即使不在程序中创建任何新的线程,线程也在后台运行着。 

一个Java应用总是从main()方法开始运行,main()方法运行在一个线程内,它被称为主线程。 

一旦创建一个新的线程,就产生一个新的调用栈。


线程总体分两类:用户线程和守候线程。

当所有用户线程执行完毕的时候,JVM自动关闭。但是守候线程却不独立于JVM,守候线程一般是由操作系统或者用户自己创建的

Java线程:创建与启动

一、定义线程

 1、扩展java.lang.Thread类。

 此类中有个run()方法,应该注意其用法:

public void run()

如果该线程是使用独立的Runnable运行对象构造的,则调用该Runnable对象的run方法;否则,该方法不执行任何操作并返回。

 Thread的子类应该重写该方法。

2、实现java.lang.Runnable接口。

 void run()

使用实现接口Runnable的对象创建一个线程时,启动该线程将导致在独立执行的线程中调用对象的run方法。

 方法run的常规协定是,它可能执行任何所需的操作。

3. 使用ExecutorService、Callable、Future实现有返回结果的多线程 (前2种都是没有返回结果的)

二、实例化线程 

1、如果是扩展java.lang.Thread类的线程,则直接new即可。 

2、如果是实现了java.lang.Runnable接口的类,则用Thread的构造方法:

Thread(Runnable target) 
Thread(Runnable target, String name) 
Thread(ThreadGroup group, Runnable target) 
Thread(ThreadGroup group, Runnable target, String name) 
Thread(ThreadGroup group, Runnable target, String name, long stackSize)

三、启动线程 (本文主要说明Thread和Runnable方式定义的线程)

在线程的Thread对象上调用start()方法,而不是run()或者别的方法。 

在调用start()方法之前:线程处于新状态中,新状态指有一个Thread对象,但还没有一个真正的线程。 

在调用start()方法之后:发生了一系列复杂的事情

启动新的执行线程(具有新的调用栈);

该线程从新状态转移到可运行状态;

当该线程获得机会执行时,其目标run()方法将运行。 

注意:对Java来说,run()方法没有任何特别之处。像main()方法一样,它只是新线程知道调用的方法名称(和签名)。因此,在Runnable上或者Thread上调用run方法是合法的。但并不启动新的线程。

四、例子

 1、实现Runnable接口的多线程例子

/** 
实现Runnable接口的类

* @author leizhimin 2008-9-13 18:12:10 
*/
 
publicclass DoSomethingimplements Runnable {
    
private String name;

    
public DoSomething(String name) {
        
this.name = name;
    } 

    
publicvoid run() {
        
for (int i = 0; i < 5; i++) {
            
for (long k = 0; k < 100000000; k++) ;
            System.out.println(name + 
": " + i);
        } 
    } 
}

/** 
测试Runnable类实现的多线程程序

* @author leizhimin 2008-9-13 18:15:02 
*/
 
publicclass TestRunnable {
    
publicstaticvoid main(String[] args) {
        DoSomething ds1 = 
new DoSomething("阿三");
        DoSomething ds2 = 
new DoSomething("李四");

        Thread t1 = 
new Thread(ds1);
        Thread t2 = 
new Thread(ds2);

        t1.start(); 
        t2.start(); 
    } 
}

2、扩展Thread类实现的多线程例子

/** 
测试扩展Thread类实现的多线程程序

* @author leizhimin 2008-9-13 18:22:13 
*/
 
publicclass TestThreadextends Thread{ 
    
public TestThread(String name) {
        
super(name);
    } 

    
publicvoid run() {
        
for(int i = 0;i<5;i++){
            
for(long k= 0; k <100000000;k++);
            System.out.println(
this.getName()+" :"+i);
        } 
    } 

    
publicstaticvoid main(String[] args) {
        Thread t1 = 
new TestThread("阿三");
        Thread t2 = 
new TestThread("李四");
        t1.start(); 
        t2.start(); 
    } 
}

五、一些常见问题 

1、线程的名字,一个运行中的线程总是有名字的,名字有两个来源,一个是虚拟机自己给的名字,一个是你自己的定的名字。在没有指定线程名字的情况下,虚拟机总会为线程指定名字,并且主线程的名字总是mian,非主线程的名字不确定。
2、线程都可以设置名字,也可以获取线程的名字,连主线程也不例外。
3、获取当前线程的对象的方法是:Thread.currentThread()
4、在上面的代码中,只能保证:每个线程都将启动,每个线程都将运行直到完成。一系列线程以某种顺序启动并不意味着将按该顺序执行。对于任何一组启动的线程来说,调度程序不能保证其执行次序,持续时间也无法保证。
5、当线程目标run()方法结束时该线程完成。
6、一旦线程启动,它就永远不能再重新启动。只有一个新的线程可以被启动,并且只能一次。一个可运行的线程或死线程可以被重新启动。7、线程的调度是JVM的一部分,在一个CPU的机器上上,实际上一次只能运行一个线程。一次只有一个线程栈执行。JVM线程调度程序决定实际运行哪个处于可运行状态的线程。众多可运行线程中的某一个会被选中做为当前线程。可运行线程被选择运行的顺序是没有保障的。
8、尽管通常采用队列形式,但这是没有保障的。队列形式是指当一个线程完成一轮时,它移到可运行队列的尾部等待,直到它最终排队到该队列的前端为止,它才能被再次选中。事实上,我们把它称为可运行池而不是一个可运行队列,目的是帮助认识线程并不都是以某种有保障的顺序排列唱呢个一个队列的事实。
9、尽管我们没有无法控制线程调度程序,但可以通过别的方式来影响线程调度的方式。


Java线程:线程栈模型与线程的变量

Java线程:线程状态的转换

一、线程状态 

线程的状态转换是线程控制的基础。线程状态总的可分为五大状态:分别是生、死、可运行、运行、等待/阻塞。用一个图来描述如下:

一张图让你看懂JAVA线程间的状态转换



线程间的状态转换: 

1. 新建(new):新创建了一个线程对象,新创建了一个线程对象, 还没有在其上调用start()方法。还没有在其上调用start()方法

2. 可运行(runnable):线程对象创建后,其他线程(比如main线程)调用了该对象的start()方法。该状态的线程位于可运行线程池中,等待被线程调度选中,获取cpu 的使用权 。在线程运行之后或者从阻塞、等待或睡眠状态回来后,也返回到可运行状态。

3. 运行(running):可运行状态(runnable)的线程获得了cpu 时间片(timeslice) ,执行程序代码。

4. 阻塞(block):阻塞状态是指线程因为某种原因放弃了cpu 使用权,也即让出了cpu timeslice,暂时停止运行。直到线程进入可运行(runnable)状态,才有机会再次获得cpu timeslice 转到运行(running)状态。阻塞的情况分三种: 

(一). 等待阻塞:运行(running)的线程执行o.wait()方法,JVM会把该线程放入等待队列(waitting queue)中。

(二). 同步阻塞:运行(running)的线程在获取对象的同步锁时,若该同步锁被别的线程占用,则JVM会把该线程放入锁池(lock pool)中。

(三). 其他阻塞:运行(running)的线程执行Thread.sleep(long ms)或t.join()方法,或者发出了I/O请求时,JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时,线程重新转入可运行(runnable)状态。

5. 死亡(dead):线程run()、main() 方法执行结束,或者因异常退出了run()方法,则该线程结束生命周期。死亡的线程不可再次复生。如果在一个死去的线程上调用start()方法,会抛出java.lang.IllegalThreadStateException异常

二、阻止线程执行
对于线程的阻止,考虑一下三个方面,不考虑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、线程调度程序可以决定将当前运行状态移动到可运行状态,以便让另一个线程获得运行机会,而不需要任何理由。


本文出自 “熔 岩” 博客,转载请与作者联系!


0 0