JavaSE第一百讲：线程同步问题深度剖析

1. 线程的生命周期：一个线程从创建到消亡的过程

线程的生命周期可分为四个状态：

1) 创建状态

2) 可运行状态 [当创建状态的时候调用了start()方法之后进入可运行状态，可运行状态是具备了运行的条件，但是还没真正运行，在等待CPU的调度]

3) 不可运行状态 [若可运行状态抢占到CPU的资源后，得到CPU调度则进入运行时状态。若碰到I/O的输入则进入阻塞状态，等I/O输入完成，进入可运行状态的就绪队列中]

4) 消亡状态

图100-1：线程的状态转换图

1)  创建状态

• 当用new操作符创建一个新的线程对象时，该线程处于创建状态。

• 处于创建状态的线程只是一个空的线程对象，系统不为它分配资源

2)  可运行状态

• 执行线程的start()方法将为线程分配必须的系统资源，安排其运行，并调用线程体—run()方法，这样就使得该线程处于可运行( Runnable )状态。

• 这一状态并不是运行中状态（Running )，因为线程也许实际上并未真正运行。

3)  不可运行状态

(1) 当发生下列事件时，处于运行状态的线程会转入到不可运行状态。

• 调用了sleep（）方法；[进入睡眠]

查看JDK Thread类中的sleep()方法

public static void sleep(long millis) throws InterruptedException

它接受一个long类型的参数为毫秒数，调用这个方法使线程进入睡眠，睡眠时间为后面传递的毫秒参数。

• 线程调用wait方法等待特定条件的满足

• 线程输入/输出阻塞

(2) 返回可运行状态：

• 处于睡眠状态的线程在指定的时间过去后

• 如果线程在等待某一条件，另一个对象必须通过notify()或notifyAll()方法通知等待线程条件的改变

• 如果线程是因为输入/输出阻塞，等待输入/输出完成

4)  消亡状态

当线程的run方法执行结束后，该线程自然消亡。

2. 线程的优先级

1) 线程的优先级及其设置

设置优先级是为了在多线程环境中便于系统对线程的调度，优先级高的线程将优先执行。

一个线程的优先级设置遵从以下原则：

1) 线程创建时，子继承父的优先级

2) 线程创建后，可通过调用setPriority()方法改变优先级。

3) 线程的优先级是1-10之间的正整数。

1 - MIN_PRIORITY,

10 – MAX_PRIORITY

5- NORM_PRIORITY

查看JDK 中Thread类的setPriority()方法：

public final void setPriority(int newPriority) [它接受的是一个常量，1-10之间的整数]

查看Thread类的定义的三个常量如下所示：

【注意】：线程的优先级不是很重要的，其实线程的优先级很多时候都是底层的操作系统来决定。因为即便你定义了几个线程的优先级，如果系统有另外的高的优先级，那你的定义的那些优先级也会被剥脱的。

所以操作系统中的优先级不是静态的，它是动态的，它会根据等待时间慢慢提高你的优先级，让你能够更多的机会被执行。所以应该由我们的代码去决定谁应该先执行，谁应该后执行。

2) 线程的调度策略

线程调度器选择优先级最高的线程运行。但是，如果发生以下情况，就会终止线程的运行。

1) 线程体中调用了yield()方法，让出了对CPU的占用权

查看JDK Doc文档中Thread类的yield()方法

public static void yield()

[它会让出对CPU的使用权，让其他的线程先去执行]

2) 线程体中调用了sleep()方法, 使线程进入睡眠状态

3) 线程由于I/O操作而受阻塞

4) 另一个更高优先级的线程出现

5) 在支持时间片的系统中，该线程的时间片用完。

3. 程序Demo

package com.ahuier.thread;

public class ThreadTest3 {
    public static void main(String[] args) {
        Runnable r = new HelloThread();
        Thread t1 = new Thread(r);
        Thread t2 = new Thread(r);
        t1.start();
        t2.start();
    }
}

class HelloThread implements Runnable{
    
    int i;
    
    @Override
    public void run() {
        /*
         * 使用while(true)方式来终止线程
         */
        while(true){
            System.out.println("number: " + i++);
            try {
                Thread.sleep((long)(Math.random() * 1000)); //睡眠在[0,1)秒之间
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            if(50 == i){
                break;
            }
        }
    }
}

编译执行结果输出number：0 -- number：49

程序修改一下，HelloThread类里面 注释掉，成员变量i,将其放在run()方法中作为局部变量如下所示：

 //   int i;
    
    @Override
    public void run() {
        int i = 0;
        /*
         * 使用while(true)方式来终止线程
         */

编译执行结果输出100个数字，而且不是规则的输出，是乱序的输出。

【说明】：第一个程序i是定义为成员变量，而我们main()方法是定义为：

        Runnable r = new HelloThread();
        Thread t1 = new Thread(r);
        Thread t2 = new Thread(r);

也就是说一个r对象，线程在访问成员变量的时候是通过一个对象生成两个线程t1 和 t2，那么这两个线程是共享这同一个成员变量，换句话说现在确实是两个线程，他们访问的是同一个对象里面的成员变量，因为这个成员变量是归属于对象本身的。

第二个程序i是定义为局部变量，对于局部变量来说，线程在访问的时候，每一个线程都会拥有自己的一个局部变量的拷贝。也就是两个线程都会去执行run()方法，他们都用各自的局部变量i，而线程之间是互不影响的。

继续修改这个程序如下main()方法

        Runnable r = new HelloThread();
        Thread t1 = new Thread(r);
        r = new HelloThread();
        Thread t2 = new Thread(r);
        t1.start();
        t2.start();

HelloThread类

    
    int i;
    @Override
    public void run() {
    //	int i = 0;
        /*
         * 使用while(true)方式来终止线程
         */

编译执行结果输出100个数字，而且不是规则的输出，是乱序的输出。

【说明】：此时它两个r对象，分别对于不同的线程，它们之间是互不关联的

继续修改程序HelloThread类：

  //  int i;
    @Override
    public void run() {
    	int i = 0;
        /*
         * 使用while(true)方式来终止线程
         */

编译执行结果输出100个数字，而且不是规则的输出，是乱序的输出。

【说明】：此时编译它们各自执行各自线程中的run()方法。每个线程都有对i的一份拷贝。

继续修改程序

        Runnable r = new HelloThread();
        Thread t1 = new Thread(r);
   //     r = new HelloThread();
        Thread t2 = new Thread(r);
        t1.start();
        t2.start();

HelloThread类

    int i;
    @Override
    public void run() {
    	int i = 0;
        /*
         * 使用while(true)方式来终止线程
         */
        while(true){

编译执行结果输出100个数字，而且不是规则的输出，是乱序的输出。

【说明】：此时局部变量的i把成员变量覆盖掉了

继续修改程序：

HelloThread类：

    int i;
    @Override
    public void run() {
    	int i = 0;
        /*
         * 使用while(true)方式来终止线程
         */
        while(true){
            System.out.println("number: " + this.i++);
            try {
                Thread.sleep((long)(Math.random() * 1000)); //睡眠在[0,1)秒之间
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            if(50 == this.i){
                break;
            }
        }
    }

编译结果生成的是50个数字，并且顺序输出，因为此时访问到的是成员变量，加了this关键字之后。

4. 总结

1) 关于成员变量与局部变量：如果一个变量是成员变量，那么多个线程对同一个对象 的成员变量进行操作时，他们对该成员变量是彼此影响的（也就是说一个线程对成 员变量的改变会影响到另一个线程）。 

2) 如果一个变量是局部变量，那么每个线程都会有一个该局部变量的拷贝，一个线程 对该局部变量的改变不会影响到其他的线程。 

3) 停止线程的方式：不能使用 Thread 类的 stop 方法来终止线程的执行。一般要设定一 个变量，在 run 方法中是一个循环，循环每次检查该变量，如果满足条件则继续执 行，否则跳出循环，线程结束。 

4) 不能依靠线程的优先级来决定线程的执行顺序。