Java 线程浅析

标签：命令   nat   join   private   优先级   stat   gets   ack   运行   

四、线程的调度（状态的变化）
我们先来看一张图：线程的调度对线程状态的影响

1）NEW(状态)线程创建未启动时的状态。如下代码示例：

Thread thread = new Thread(new ThreadTest());
        System.out.println(thread.getState());

输出结果：
NEW

Process finished with exit code 0
2）NEW-RUNNABLE线程调用start方法。如下代码示例：

Thread thread = new Thread(new ThreadTest());
        thread.start();
        System.out.println(thread.getState());

输出结果：
RUNNABLE
线程调用yield（）方法，yield方法的作用就是让出CPU，当前线程从运行中变为可运行状态（READY），让和它同级或者更高级别的线程运行，但是不能保证运行的线程立马变成可运行状态（不确定的）。看如下代码示例：
代码设置了线程的优先级，但是测试了几次的测试结果都不相同。

**
 * 测试yield方法
 */
public class ThreadYieldTest {

    public static void main (String[] args) {
        Thread threadone = new Thread(new ThreadTestOne(),"ThreadTestOne");
        Thread threadtwo = new Thread(new ThreadTestTwo(),"ThreadTestTwo");
        threadone.setPriority(Thread.MIN_PRIORITY);
        threadtwo.setPriority(Thread.MAX_PRIORITY);
        threadone.start();
        threadtwo.start();
    }

    static class ThreadTestOne implements Runnable {

        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                System.out.println("ThreadTestOne----MIN_PRIORITY-----"+i);
                Thread.yield();
            }
        }
    }

    static class ThreadTestTwo implements Runnable {

        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                System.out.println("ThreadTestTwo-----MAX_PRIORITY----"+i);
                Thread.yield();
            }
        }
    }
}

结果一：
ThreadTestOne----MIN_PRIORITY-----0
ThreadTestTwo-----MAX_PRIORITY----0
ThreadTestOne----MIN_PRIORITY-----1
ThreadTestTwo-----MAX_PRIORITY----1
结果二：
ThreadTestTwo-----MAX_PRIORITY----0
ThreadTestOne----MIN_PRIORITY-----0
ThreadTestTwo-----MAX_PRIORITY----1
ThreadTestOne----MIN_PRIORITY-----1
ThreadTestTwo-----MAX_PRIORITY----2
ThreadTestTwo-----MAX_PRIORITY----3

3）RUNNABLE-WAITING（调用wait、join等方法）
（1）、wait方法可以让一个线程的状态变为WAITING或者TIME_WAITING，wait方法的作用是让当前线程进入等待队列，让出CPU的执行权，线程的状态变化为等待状态，执行wait方法的前提就是获取到对象锁，因为执行线程需要知道进入谁的等待队列，之后才能被谁唤醒。看如下代码示例：（jps 看java的进程id,jstack 看java线程的信息）

static class Parent implements Runnable {

        @Override
        public void run() {
            synchronized (lock){
                System.out.println("执行lock.wait");
                try {
                    lock.wait();
                    // 不会执行
                    System.out.println(Thread.currentThread().getName()+"----------"+Thread.currentThread().getState());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

通过命令看下线程信息如下图所示：可以看到Thread.State:WAITING

(2)、join方法也可以使线程以让一个线程的状态变为WAITING或者TIME_WAITING，join的方法的作用,字面意思加入、参加。我们可以这么理解join方法，一个线程加入一个正在运行的主线程中，并且使得正在运行的主线程等待加入的线程执行完毕才能继续执行。看如下代码示例：
1、我们在main方法启动两个线程，分别调用jion方法和不调用，看下执行结果一（不调用join方法）：
Parent-----------------
Child-----------
结果顺序不确定
Child-----------
Parent-----------------

public static void main (String[] args) {
        Thread thread = new Thread(new Parent());
        thread.setName("Parent");

        Thread threadChild = new Thread(new Child());
        threadChild.setName("Child");

        thread.start();
        threadChild.start();
    }

    /**
     * 父线程
     */
    static class Parent implements Runnable {

        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName()+"-----------------");
        }
    }

    /**
     * 子线程
     */
    static class Child  implements Runnable {

        @Override
        public void run() {
                System.out.println(Thread.currentThread().getName()+"-----------");
        }
    }

结果二（其中一个调用join方法）
(多次运行结果顺序不变)
Parent-----------------
Child-----------

public static void main (String[] args) {
        Thread thread = new Thread(new Parent());
        thread.setName("Parent");

        Thread threadChild = new Thread(new Child());
        threadChild.setName("Child");

        thread.start();
        try {
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        threadChild.start();
    }

2、join方法源码
可以看出join方法是调用的wait方法，所以线程的状态会变成WAITING或者TIME_WAITING。
我们来分析下是哪个线程加入等待队列，可以看出join方法是个synchronized方法，也就是说锁对象就是调用者，然后拥有锁对象的线程调用wait方法进入等待队列。我们通过上面的main方法来分析到底是谁进入等待队列，主角有main线程、Parent线程、Child线程，我们在main线程里面new了Parent线程和Child线程，然后在Child线程启动前面调用了Parent线程的join方法，也就是说是Parent线程调用了join方法，所以锁对象就是Parent线程实例，我们再来分析是那个线程拥有这个锁对象，答案是main线程，所以main线程调用wait方法进入等待队列Parent线程执行完毕；join方法结束时会唤醒主线程。

public final synchronized void join(long millis)
    throws InterruptedException {
        long base = System.currentTimeMillis();
        long now = 0;

        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (millis == 0) {
            while (isAlive()) {
                wait(0);
            }
        } else {
            while (isAlive()) {
                long delay = millis - now;
                if (delay <= 0) {
                    break;
                }
                wait(delay);
                now = System.currentTimeMillis() - base;
            }
        }
    }

4）RUNNABLE-TIME_WAITING（调用sleep、wait、join等方法）
sleep(long)方法就是让线程睡眠一定的时间在执行，不过这个是有时间限制的，到了时间就会又变成RUNNABLE状态。如下代码示例：

static class Parent implements Runnable {

        @Override
        public void run() {
            try {
                Thread.sleep(1000);
                System.out.println("-----------------------");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

结果

join(long)和wait(long)方法和WAITING状态的方式类似，只是加入时间后线程可以自动唤醒，自动从等待队列加入同步队列，获取到锁变成RUNNABLE状态。
sleep和wait的区别:
相同点：sleep和wait都可以使线程等待特定的时间；都可以使用interrupt()后调用阻塞方法中断线程；
不同点：sleep是Thread方法，wait是Object的方法；slepp到了时间自动唤醒，而wait没有规定时间时需要手动唤醒；在synchronized关键字修饰的方法或者块中，sleep不会释放锁，wait会释放锁。
4）TIME_WAITING or WAITING-RUNNABLE（调用notify()、notifyAll()，sleep时间到了)
sleep时间到了线程就会进入RUNNABLE状态（但是可能是RUNNING or READY状态）。
notify()是唤醒一个线程，进入同步队列，没有获取到锁就是BLOCKED状态，获取到锁就是RUNNABLE状态。
notifyAll()是唤醒等待队列的所有线程进入同步队列。
5）RUNNABLE-BLOCKED(线程获取锁失败，进入同步队列)
如下代码示例：

static class Parent implements Runnable {

        @Override
        public void run() {
            synchronized (lock) {
                    System.out.println(Thread.currentThread().getName()+"----------------------------------");
                try {
                    Thread.sleep(100000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 子线程
     */
    static class Child  implements Runnable {

        @Override
        public void run() {
            synchronized (lock) {
                System.out.println(Thread.currentThread().getName()+"----------------------------------");
            }
        }
    }

结果
6）RUNNABLE-TERMINATED(线程执行完毕)
五、如何优雅终止线程（手动）
我们知道线程提供了interrupt()、stop()方法；中断线程的三种方式；
1）stop方法，停止一个线程，现在已经是一个过期方法（不推荐使用）。
代码示例：

public static void main (String[] args) throws InterruptedException {
        Thread thread = new Thread(new Parent(),"Parent");
        thread.start();
        Thread.sleep(200);
        thread.stop();
    }

    /**
     * 父线程
     */
    static class Parent implements Runnable {

        @Override
        public void run() {
            while (true) {
                System.out.println("-----------------------");
            }
        }
    }

2) 使用interrupt()方法，只是给线程设置了一个中断标记，并不会中断线程，配合阻塞方法才能实现线程的中断。
如下代码示例：
中断了
java.lang.InterruptedException: sleep interrupted
at java.lang.Thread.sleep(Native Method)
at com.ge.thread.method.ThreadStopTest$Parent.run(ThreadStopTest.java:30)
at java.lang.Thread.run(Thread.java:745)

public static void main (String[] args)  {
        Thread thread = new Thread(new Parent(),"Parent");
        thread.start();
        thread.interrupt();
    }

    /**
     * 父线程
     */
    static class Parent implements Runnable {

        @Override
        public void run() {
            try {
                while (true) {
                    /*System.out.println("------------");
                    // 测试 isInterrupted方法
                    System.out.println("0isInterrupted------"+Thread.currentThread().isInterrupted());
                    // 测试interrupted方法
                    System.out.println("1interrupted------"+  Thread.interrupted());
                    System.out.println("2interrupted------"+  Thread.interrupted());*/
                    Thread.sleep(500);

                }
            }catch (InterruptedException e) {
                e.printStackTrace();
                System.out.println("中断了");
            }
        }
    }

interrupt、interrupted和isInterrupted方法的区别，大家可以运行上面注释代码看运行结果。
interrupt：给线程一个中断标记，配合阻塞方法中断线程，抛出InterruptedException异常，并清除标记。
interrupted：Thread的静态方法，返回线程的中断标记状态，并且清理，所以第一次返回true或者false，第二次一定是false。
isInterrupted：返回线程的中断标记状态。
3）给线程的执行设置一个标记，满足就执行，不满足就结束线程。
如下代码示例：

 private static volatile boolean flag = true;

    public static void main (String[] args) {
        Thread thread = new Thread(new Parent());
        thread.setName("Parent");
        thread.start();
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 中断线程标记
        flag = false;
    }

    /**
     * 父线程
     */
    static class Parent implements Runnable {

        @Override
        public void run() {
            while (flag && !Thread.currentThread().isInterrupted()) {
                System.out.println("--------------");
            }
        }
    }

4）总结，stop方法就是强行结束线程，不推荐可能造成业务数据未知的错误，因为线程运行在那个过程时未知的；interrupt通过标记和阻塞方法一起中断线程，会抛出异常，但是要对异常做处理，例如处理线程为执行完成的任务或者回滚保证业务正确；推荐标记法，因为线程会走一个完整的过程，不会出现业务方面的未知错误，线程要么执行，要么不执行，不会执行一半就退出，所以就不会出现未知错误。
六、总结
本文针对线程的生命周期，线程的每个状态进行解释，以及线程执行过程的状态变化；线程调度对线程状态的影响，以及一些线程的基本方法；最后介绍了停止线程的三种方式；通过学习这些有助于我们理解线程的基础，为学习多线程打下基础，只有学习好了单线程，才能更好的学习多线程；希望与诸君共勉。

Java 线程浅析

标签：命令   nat   join   private   优先级   stat   gets   ack   运行   

原文地址：https://blog.51cto.com/14220760/2380359