java多线程（2）线程生命周期和常见API

上一篇文章对java线程的一些相关概念，进行了一个认识，并且还举出了一个基本的案例，这篇文章我们将对线程的常用API和生命周期进行一个讲解分析。

一、从最简单的例子说起

再开始讲解java线程的api我们还需要先对线程有一个回顾和了解。对此，给出一个最基本的线程案例。

public class MyThread extends Thread {
    private String name;
    public MyThread(String name) {
        super();
        this.name = name;
    }
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(name + "：正在执行！" + i);
        }
    }
}

我们在这里定义了一个线程，然后在run方法中循环输出i。然后我们就可以像使用其他类一样去使用了。

public class Test {
    public static void main(String[] args) {
        MyThread myThread = new MyThread("线程一");
        myThread.start();
    }
}

这就是一个最简单的例子，我们可能会想，线程好像也没啥特殊的，new出来一个对象然后执行就结束了。那他的生命周期会不会也是和普通类一样呢？再继续往下看：

二、线程的生命周期

1、思考一个问题

在上面我们new出来一个线程实例，然后调用start方法之后，这个线程就开始执行了嘛？

在上一篇文章曾经说过，这和CPU的时间片轮询有关，CPU需要在多条线程之间切换，轮到他他才会执行。因此呢，当调用start方法之后，线程只能说有可能在执行。

2、线程的生命周期

对于线程来说，它的一生要经过五种状态：新建（New）、就绪（Runnable）、运行（Running）、阻塞（Blocked）和死亡（terminated）。

在网上看过N多个版本的线程生命周期状态图，自己也使用画图工具花了一个。

这张图基本上涵盖了线程的整个生命周期。上面的123456序号表示实现状态之间转换的方法，比如说调用了线程的某些API方法，或者是外部环境的一些改变，都能够使得线程从一个状态转变到另外一个状态，下面我们对这五个状态分别来解释一下;

（1）new状态

也就是说，在这里我们只是实例化了线程，还没有start。此时的Thread和普通的类完全没有区别。因为在这里new出来一个对象却没有使用，什么也干不了。start方法被调用之后就进入了框框里面的两个状态。

（2）runnable状态

这个状态表示没有获取CPU执行权，也就是CPU时间片还没有轮询到这个线程，此时的线程表示有了能够执行得能力，但是还没有轮到他执行而已。

（3）running状态

这个状态表示获得了CPU的执行权，然后线程里面的run方法就开始执行了。

（4）blocked状态

这个状态表示的是阻塞状态，为什么会出现这个状态呢？有常见的3个原因：

原因一：从running状态转变而来，因为调用了线程调用了sleep或者是wait方法。

原因二：突然执行了IO操作，比如文件保存或者是读取了网络文件等等。

原因三：想要获取某一个锁，但是当前获取锁的线程太多，于是去排队了。

在这个blocked状态中，可以直接到terminated状态或者是回到running状态。

（5）terminated状态

这个状态表示线程的生命周期就要结束了。

在这里上面的123456里面的内容，在我们讲解线程api的时候再进行理解，因为在这里直接列出来是什么原因造成的状态之间切换的话，到了下面就忘了。

注意：这张图时刻牢记着

三、线程常见的API

1、休眠sleep

这种方式会使得线程从running状态转变到runnable状态或者是blocked状态。

用法很简单，直接让线程去调用执行就OK了，会抛出一个InterruptedException异常：

public class Test {
    public static void main(String[] args) {
        MyThread myThread = new MyThread("线程一");
        myThread.start();
        try {
            //表示会休眠1秒钟
            myThread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

不过目前的这种做法正在被TimeUnit所取代，比如我们想要休眠的话，我们可以直接这样：

public class Test {
    public static void main(String[] args) {
        MyThread myThread = new MyThread("线程一");
        myThread.start();
        try {
            //单位是秒，直接写1即可
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

当然还有分钟、小时、天等单位。

2、中断interrupt

这种方式会线程blocked状态转变到其他状态，比如说runnable、terminated和running状态。

意思是打断当前线程的阻塞状态，就好比你正在睡觉，突然有人把你吵醒了。代码演示一下：

public class Test {
    public static void main(String[] args) {
        MyThread myThread = new MyThread("线程一");
        //myThread企图休眠一分钟
        myThread.start();
        try {
            //单位是秒，直接写1即可
            TimeUnit.SECONDS.sleep(2);
            //休眠两秒就被中断了
            myThread.interrupt();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

在myThread中企图休眠一分钟，但是在主线程main中，休眠两秒就被打断了，此时就会报错：

java.lang.InterruptedException: sleep interrupted
    at java.lang.Thread.sleep(Native Method)
    at java.lang.Thread.sleep(Thread.java:340)
    at java.util.concurrent.TimeUnit.sleep(TimeUnit.java:386)
    at com.fdd.chapter2.MyThread.run(MyThread.java:17)

上面异常的意思就是睡眠被打断了。这个方法为什么能够中断线程呢？我们来深入的理解一下：

（1）中断线程相关的方法

在线程内部有一个中断flag，如果我们执行了interrupt方法，那么这个标签将会被置为true。表示此线程被打上了中断标记，与线程中断的api还有两个：

方法	含义
interrupted	测试当前线程是否已经中断。重置flag
isInterrupted()	测试线程是否已经中断。不会重置flag
interrupt()	中断线程。重置flag

其中，interrupt 方法是唯一能将中断状态设置为 true 的方法。静态方法 interrupted 会将当前线程的中断状态清除，但这个方法的命名极不直观，很容易造成误解，需要特别注意。

（2）如何中断一个线程

在这里你可能有一个疑问，上面不是已经说调用中断方法就会中断一个线程？你先来看看下面中断失败的例子：

public class Test {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            while (true) {
            }
        });
        thread.start();
        //我们尝试中断这个线程
        thread.interrupt();
    }
}

我们尝试中断这个线程，会发现不起任何作用，这是因为你只是去中断线程，但是线程里面没有对其进行回应，就好比说别人在吃饭，你说我要把你的饭端走，别人懒得理你，继续吃一样。

所以要想中断一个线程，不仅仅要给线程一个中断信号，线程也要能够积极地响应这个中断信号。

public class Test {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            while (true) {    
                // 响应中断信号
                if (Thread.currentThread().isInterrupted()) {
                    //判断当前线程是否被中断
                    return;
                }
            }
        });
        thread.start();
        thread.interrupt();
    }
}

上面的这个例子中，线程内部积极的相应了外部的中断信号，就能够中断线程了。现在相信你稍微有点豁然开朗了

3、yied方法

这种方式会使得线程从running状态转变到runnable状态。

意思是线程告诉调度器，愿意放弃当前的CPU资源，你可以去执行其他的线程了。当然调度器比较忙的时候，可以不用搭理这个线程的请求。

public class Test {
    public static void main(String[] args) {
        MyThread myThread = new MyThread("线程一");
        myThread.start();
        try {
            myThread.yield();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

4、线程优先级

（1）设置线程优先级

优先级高的话表示线程优先调用，但不是绝对的被优先调用。就好比是线程告诉调度器，想要更高的权限去获取CPU资源，但是调度器同样可以忽略他的请求。

优先级有1到10。数字越大优先级越大。

public class Test {
    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {     
            System.out.println("优先级4");
        });

        Thread thread2 = new Thread(() -> {
            System.out.println("优先级8");
        });
        thread1.setPriority(4);
        thread2.setPriority(8);
        thread1.start();
        thread2.start();
    }
}

在这里线程2就可能比线程1先执行。

（2）获取优先级

public class Test {
    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {});
        Thread thread2 = new Thread(() -> {});

        System.out.println(thread1.getPriority());
        System.out.println(thread2.getPriority());
        thread1.start();
        thread2.start();
    }
}

这两个线程的优先级如果不提前设置都是5.

5、join方法

此方法可以使其他线程从running状态转换到blocked状态。
join线程A之后，其他的线程必须要等待线程A执行结束才可以执行。此时其他的线程一直处于bloecked。我们可以看一下例子：

新建一个线程：

public class MyThread extends Thread {
    private String name;
    public MyThread(String name) {
        super();
        this.name = name;
    }
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(name+i);
        }

    }
}

然后我们使用一下join方法：

public class Test {
    public static void main(String[] args) {
        MyThread thread1 = new MyThread("线程A");
        MyThread thread2 = new MyThread("线程B");
        thread1.start();
        try {
            thread2.start();
            thread2.join(); 
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
}

在这里就是让线程B先执行完再执行线程A，但这里并不是绝对的，因为在start线程B之前，可能CPU刚好执行了线程A，于是输出了一个线程A，然后轮到线程B的时候，就会一下子全部输出。

6、getId获得线程ID

线程的ID在整个jvm中都是唯一的。

public class Test {
    public static void main(String[] args) {
        Thread thread = new Thread(()->{}) ;
        System.out.println(thread.getId());
    }
}

要注意，在这里输出的线程ID不是从0开始的，因为再执行一个程序的时候，jvm会默认开辟很多个线程。

7、获取当前线程

public class Test {
    public static void main(String[] args) {
        Thread thread = new Thread(()->{}) ;
        System.out.println(Thread.currentThread());
    }
}
//输出：
Thread[main,5,main]

以上就是常用的一些api。还有一个stop关闭线程的方法，但是一般不会用到。

到现在为止我们已经分析了其生命周期和常用的API，但是还有一点就是我们好像还没说过线程的源码，下一节就对线程的源码进行一个分析，最主要的就是其构造函数的使用，也揭晓一下为什么调用start方法就启动了一个线程。