Java线程：概念与原理

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

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

进程是指一个内存中执行的应用程序。每一个进程都有自己独立的一块内存空间。一个进程中能够启动多个线程。

比方在Windows系统中。一个执行的exe就是一个进程。

线程是指进程中的一个执行流程。一个进程中能够执行多个线程。比方java.exe进程中能够执行非常多线程。

线程总是属于某个进程，进程中的多个线程共享进程的内存。

“同一时候”运行是人的感觉，在线程之间实际上轮换运行。

二、Java中的线程

在Java中。“线程”指两件不同的事情：
1、java.lang.Thread类的一个实例；

2、线程的运行。

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

一个Thread类实例仅仅是一个对象，像Java中的不论什么其它对象一样，具有变量和方法。生死于堆上。

Java中，每一个线程都有一个调用栈。即使不在程序中创建不论什么新的线程，线程也在后台执行着。

一个Java应用总是从main()方法開始执行，mian()方法执行在一个线程内。它被称为主线程。

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

线程整体分两类：用户线程和守候线程。

当全部用户线程运行完成的时候。JVM自己主动关闭。

可是守候线程却不独立于JVM，守候线程通常是由操作系统或者用户自己创建的

Java线程：创建与启动

一、定义线程

1、扩展java.lang.Thread类。

此类中有个run()方法，应该注意其使用方法：

public void run()

假设该线程是使用独立的Runnable执行对象构造的。则调用该Runnable对象的run方法；否则，该方法不执行不论什么操作并返回。

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

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

void run()

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

方法run的常规协定是，它可能运行不论什么所需的操作。

二、实例化线程

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对象上调用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(); 
    } 
}

运行结果：

李四: 0
阿三: 0 
李四: 1 
阿三: 1 
李四: 2 
李四: 3 
阿三: 2 
李四: 4 
阿三: 3 
阿三: 4 

Process finished with exit code 0

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(); 
    } 
}

运行结果：

阿三 :0
李四 :0 
阿三 :1 
李四 :1 
阿三 :2 
李四 :2 
阿三 :3 
阿三 :4 
李四 :3 
李四 :4 

Process finished with exit code 0

对于上面的多线程程序代码来说，输出的结果是不确定的。当中的一条语句for(long k= 0; k <100000000;k++);是用来模拟一个很耗时的操作的。

五、一些常见问题

1、线程的名字，一个执行中的线程总是有名字的，名字有两个来源，一个是虚拟机自己给的名字，一个是你自己的定的名字。在没有指定线程名字的情况下，虚拟机总会为线程指定名字，而且主线程的名字总是mian，非主线程的名字不确定。

2、线程都能够设置名字。也能够获取线程的名字，连主线程也不例外。

3、获取当前线程的对象的方法是：Thread.currentThread()。

4、在上面的代码中，仅仅能保证：每一个线程都将启动，每一个线程都将运行直到完毕。一系列线程以某种顺序启动并不意味着将按该顺序运行。对于不论什么一组启动的线程来说，调度程序不能保证其运行次序，持续时间也无法保证。

5、当线程目标run()方法结束时该线程完毕。

6、一旦线程启动，它就永远不能再又一次启动。

仅仅有一个新的线程能够被启动，而且仅仅能一次。一个可执行的线程或死线程能够被又一次启动。

7、线程的调度是JVM的一部分。在一个CPU的机器上上，实际上一次仅仅能执行一个线程。

一次仅仅有一个线程栈执行。JVM线程调度程序决定实际执行哪个处于可执行状态的线程。

众多可执行线程中的某一个会被选中做为当前线程。可执行线程被选择执行的顺序是没有保障的。

8、虽然通常採用队列形式。但这是没有保障的。

队列形式是指当一个线程完毕“一轮”时，它移到可执行队列的尾部等待。直到它终于排队到该队列的前端为止，它才干被再次选中。其实，我们把它称为可执行池而不是一个可执行队列，目的是帮助认识线程并不都是以某种有保障的顺序排列唱呢个一个队列的事实。

9、虽然我们没有无法控制线程调度程序，但能够通过别的方式来影响线程调度的方式。

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

要理解线程调度的原理。以及线程运行过程。必须理解线程栈模型。

线程栈是指某时刻时内存中线程调度的栈信息，当前调用的方法总是位于栈顶。线程栈的内容是随着程序的执行动态变化的，因此研究线程栈必须选择一个执行的时刻（实际上指代码执行到什么地方)。

以下通过一个演示样例性的代码说明线程（调用）栈的变化过程。

这幅图描写叙述在代码运行到两个不同一时候刻1、2时候，虚拟机线程调用栈示意图。

当程序运行到t.start();时候，程序多出一个分支（添加了一个调用栈B），这样，栈A、栈B并行运行。

从这里就能够看出方法调用和线程启动的差别了。

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 
*/ 
publicclass MyThreadextends Thread {

    publicvoid 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(); 
            } 
        } 
    } 

    publicstaticvoid 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、线程调度程序能够决定将当前执行状态移动到可执行状态，以便让还有一个线程获得执行机会，而不须要不论什么理由。