在上一篇文章中并发编程的优缺点谈到了为什么花功夫去学习并发编程的技术，也就是说咱们必须理解到并发编程的优缺点，咱们在什么状况下能够去思考开启多个线程去实现咱们的业务，当然应用多线程咱们应该着重留神一些什么，在上一篇文章中会有一些探讨。那么，说了这么多，无论是针对面试还是理论工作中作为一名软件开发人员都应该具备这样的技能。万事开头难，接下来就应该理解如何新建一个线程？线程状态是怎么转换的？对于线程状态的操作是怎么的？这篇文章就次要围绕这三个方面来聊一聊。
1. 新建线程
一个java程序从main()办法开始执行，而后依照既定的代码逻辑执行，看似没有其余线程参加，但实际上java程序天生就是一个多线程程序，蕴含了：
（1）散发解决发送给给JVM信号的线程；
（2）调用对象的finalize办法的线程；
（3）革除Reference的线程；
（4）main线程，用户程序的入口；
那么，如何在用户程序中新建一个线程了，只有有三种形式：
- 通过继承Thread类，重写run办法；
- 通过实现runable接口；
通过实现callable接口这三种形式，上面看具体demo。
public class CreateThreadDemo { public static void main(String[] args) { //1.继承Thread Thread thread = new Thread() { @Override public void run() { System.out.println("继承Thread"); super.run(); } }; thread.start(); //2.实现runable接口 Thread thread1 = new Thread(new Runnable() { @Override public void run() { System.out.println("实现runable接口"); } }); thread1.start(); //3.实现callable接口 ExecutorService service = Executors.newSingleThreadExecutor(); Future<String> future = service.submit(new Callable() { @Override public String call() throws Exception { return "通过实现Callable接口"; } }); try { String result = future.get(); System.out.println(result); } catch (InterruptedException e) { e.printStackTrace(); } catch (ExecutionException e) { e.printStackTrace(); } } }
三种新建线程的形式具体看以上正文，须要次要的是：
- 因为java不能多继承能够实现多个接口，因而，在创立线程的时候尽量多思考采纳实现接口的模式；
- 实现callable接口，提交给ExecutorService返回的是异步执行的后果，另外，通常也能够利用FutureTask(Callable callable)将callable进行包装而后FeatureTask提交给ExecutorsService。如图：
另外因为FeatureTask也实现了Runable接口也能够利用下面第二种形式（实现Runable接口）来新建线程；
- 能够通过Executors将Runable转换成Callable，具体方法是：Callable callable(Runnable task, T result)， Callable callable(Runnable task)。
2. 线程状态转换
此图来源于《JAVA并发编程的艺术》一书中，线程是会在不同的状态间进行转换的，java线程线程转换图如上图所示。线程创立之后调用start()办法开始运行，当调用wait(),join(),LockSupport.lock()办法线程会进入到WAITING状态，而同样的wait(long timeout)，sleep(long),join(long),LockSupport.parkNanos(),LockSupport.parkUtil()减少了超时期待的性能，也就是调用这些办法后线程会进入TIMED_WAITING状态，当超时等待时间达到后，线程会切换到Runable的状态，另外当WAITING和TIMED _WAITING状态时能够通过Object.notify(),Object.notifyAll()办法使线程转换到Runable状态。当线程呈现资源竞争时，即期待获取锁的时候，线程会进入到BLOCKED阻塞状态，当线程获取锁时，线程进入到Runable状态。线程运行完结后，线程进入到TERMINATED状态，状态转换能够说是线程的生命周期。另外须要留神的是：
- 当线程进入到synchronized办法或者synchronized代码块时，线程切换到的是BLOCKED状态，而应用java.util.concurrent.locks下lock进行加锁的时候线程切换的是WAITING或者TIMED_WAITING状态，因为lock会调用LockSupport的办法。
用一个表格将下面六种状态进行一个总结演绎。
3. 线程状态的基本操作
除了新建一个线程外，线程在生命周期内还有须要基本操作，而这些操作会成为线程间一种通信形式，比方应用中断（interrupted）形式告诉实现线程间的交互等等，上面就将具体说说这些操作。3.1. interrupted
中断能够了解为线程的一个标记位，它示意了一个运行中的线程是否被其余线程进行了中断操作。中断好比其余线程对该线程打了一个招呼。其余线程能够调用该线程的interrupt()办法对其进行中断操作，同时该线程能够调用 isInterrupted（）来感知其余线程对其本身的中断操作，从而做出响应。另外，同样能够调用Thread的静态方法 interrupted（）对以后线程进行中断操作，该办法会革除中断标记位。须要留神的是，当抛出InterruptedException时候，会革除中断标记位，也就是说在调用isInterrupted会返回false。
上面联合具体的实例来看一看
public class InterruptDemo { public static void main(String[] args) throws InterruptedException { //sleepThread睡眠1000ms final Thread sleepThread = new Thread() { @Override public void run() { try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } super.run(); } }; //busyThread始终执行死循环 Thread busyThread = new Thread() { @Override public void run() { while (true) ; } }; sleepThread.start(); busyThread.start(); sleepThread.interrupt(); busyThread.interrupt(); while (sleepThread.isInterrupted()) ; System.out.println("sleepThread isInterrupted: " + sleepThread.isInterrupted()); System.out.println("busyThread isInterrupted: " + busyThread.isInterrupted()); }}输入后果
sleepThread isInterrupted: false busyThread isInterrupted: true
开启了两个线程别离为sleepThread和BusyThread, sleepThread睡眠1s，BusyThread执行死循环。而后别离对着两个线程进行中断操作，能够看出sleepThread抛出InterruptedException后革除标记位，而busyThread就不会革除标记位。
另外，同样能够通过中断的形式实现线程间的简略交互， while (sleepThread.isInterrupted()) 示意在Main中会继续监测sleepThread，一旦sleepThread的中断标记位清零，即sleepThread.isInterrupted()返回为false时才会持续Main线程才会持续往下执行。因而，中断操作能够看做线程间一种简便的交互方式。个别在完结线程时通过中断标记位或者标记位的形式能够有机会去清理资源，绝对于果断而间接的完结线程，这种形式要优雅和平安。
3.2. join
join办法能够看做是线程间合作的一种形式，很多时候，一个线程的输出可能十分依赖于另一个线程的输入，这就像两个好基友，一个基友先走在后面忽然看见另一个基友落在后面了，这个时候他就会在原处等一等这个基友，等基友赶上来后，就两人携手并进。其实线程间的这种合作形式也合乎现实生活。在软件开发的过程中，从客户那里获取需要后，须要通过需要分析师进行需要合成后，这个时候产品，开发才会持续跟进。如果一个线程实例A执行了threadB.join(),其含意是：以后线程A会期待threadB线程终止后threadA才会继续执行。对于join办法一共提供如下这些办法:
public final synchronized void join(long millis) public final synchronized void join(long millis, int nanos) public final void join() throws InterruptedException
Thread类除了提供join()办法外，另外还提供了超时期待的办法，如果线程threadB在期待的工夫内还没有完结的话，threadA会在超时之后继续执行。join办法源码要害是：
while (isAlive()) { wait(0); }能够看进去以后期待对象threadA会始终阻塞，直到被期待对象threadB完结后即isAlive()返回false的时候才会完结while循环，当threadB退出时会调用notifyAll()办法告诉所有的期待线程。上面用一个具体的例子来说说join办法的应用：
public class JoinDemo { public static void main(String[] args) { Thread previousThread = Thread.currentThread(); for (int i = 1; i <= 10; i++) { Thread curThread = new JoinThread(previousThread); curThread.start(); previousThread = curThread; } } static class JoinThread extends Thread { private Thread thread; public JoinThread(Thread thread) { this.thread = thread; } @Override public void run() { try { thread.join(); System.out.println(thread.getName() + " terminated."); } catch (InterruptedException e) { e.printStackTrace(); } } }}输入后果为：
main terminated. Thread-0 terminated. Thread-1 terminated. Thread-2 terminated. Thread-3 terminated. Thread-4 terminated. Thread-5 terminated. Thread-6 terminated. Thread-7 terminated. Thread-8 terminated.
在下面的例子中一个创立了10个线程，每个线程都会期待前一个线程完结才会持续运行。能够艰深的了解成接力，前一个线程将接力棒传给下一个线程，而后又传给下一个线程......
3.3 sleep
public static native void sleep(long millis)办法显然是Thread的静态方法，很显然它是让以后线程依照指定的工夫休眠，其休眠工夫的精度取决于处理器的计时器和调度器。须要留神的是如果以后线程取得了锁，sleep办法并不会失去锁。sleep办法常常拿来与Object.wait()办法进行比价，这也是面试常常被问的中央。
sleep() VS wait()
两者次要的区别：
- sleep()办法是Thread的静态方法，而wait是Object实例办法
- wait()办法必须要在同步办法或者同步块中调用，也就是必须曾经取得对象锁。而sleep()办法没有这个限度能够在任何中央种应用。另外，wait()办法会开释占有的对象锁，使得该线程进入期待池中，期待下一次获取资源。而sleep()办法只是会让出CPU并不会开释掉对象锁；
- sleep()办法在休眠工夫达到后如果再次取得CPU工夫片就会继续执行，而wait()办法必须期待Object.notift/Object.notifyAll告诉后，才会来到期待池，并且再次取得CPU工夫片才会继续执行。
3.4 yield
public static native void yield();这是一个静态方法，一旦执行，它会是以后线程让出CPU，然而，须要留神的是，让出的CPU并不是代表以后线程不再运行了，如果在下一次竞争中，又取得了CPU工夫片以后线程仍然会持续运行。另外，让出的工夫片只会调配给以后线程雷同优先级的线程。什么是线程优先级了？上面就来具体聊一聊。
古代操作系统根本采纳时候的模式调度运行的线程，操作系统会分出一个个工夫片，线程会调配到若干工夫片，以后工夫片用完后就会产生线程调度，并期待这下次调配。线程调配到的工夫多少也就决定了线程应用处理器资源的多少，而线程优先级就是决定线程须要或多或少调配一些处理器资源的线程属性。
在Java程序中，通过一个整型成员变量Priority来管制优先级，优先级的范畴从1~10.在构建线程的时候能够通过**setPriority(int)**办法进行设置，默认优先级为5，优先级高的线程相较于优先级低的线程优先取得处理器工夫片。须要留神的是在不同JVM以及操作系统上，线程布局存在差别，有些操作系统甚至会疏忽线程优先级的设定。
sleep() VS yield()
另外须要留神的是，sleep()和yield()办法，同样都是以后线程会交出处理器资源，而它们不同的是，sleep()交进去的工夫片其余线程都能够去竞争，也就是说都有机会取得以后线程让出的工夫片。而yield()办法只容许与以后线程具备雷同优先级的线程可能取得释放出来的CPU工夫片。
4.守护线程Daemon
守护线程是一种非凡的线程，就和它的名字一样，它是零碎的守护者，在后盾默默地守护一些零碎服务，比方垃圾回收线程，JIT线程就能够了解守护线程。与之对应的就是用户线程，用户线程就能够认为是零碎的工作线程，它会实现整个零碎的业务操作。用户线程齐全完结后就意味着整个零碎的业务工作全副完结了，因而零碎就没有对象须要守护的了，守护线程自然而然就会退。当一个Java利用，只有守护线程的时候，虚拟机就会天然退出。上面以一个简略的例子来表述Daemon线程的应用。
public class DaemonDemo { public static void main(String[] args) { Thread daemonThread = new Thread(new Runnable() { @Override public void run() { while (true) { try { System.out.println("i am alive"); Thread.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); } finally { System.out.println("finally block"); } } } }); daemonThread.setDaemon(true); daemonThread.start(); //确保main线程完结前能给daemonThread可能分到工夫片 try { Thread.sleep(800); } catch (InterruptedException e) { e.printStackTrace(); } }}复制代码输入后果为：
i am alive finally block i am alive
下面的例子中daemodThread run办法中是一个while死循环，会始终打印,然而当main线程完结后daemonThread就会退出所以不会呈现死循环的状况。main线程先睡眠800ms保障daemonThread可能领有一次工夫片的机会，也就是说能够失常执行一次打印“i am alive”操作和一次finally块中"finally block"操作。紧接着main 线程完结后，daemonThread退出，这个时候只打印了"i am alive"并没有打印finnal块中的。因而，这里须要留神的是守护线程在退出的时候并不会执行finnaly块中的代码，所以将开释资源等操作不要放在finnaly块中执行，这种操作是不平安的
线程能够通过setDaemon(true)的办法将线程设置为守护线程。并且须要留神的是设置守护线程要先于start()办法，否则会报
Exception in thread "main" java.lang.IllegalThreadStateException at java.lang.Thread.setDaemon(Thread.java:1365) at learn.DaemonDemo.main(DaemonDemo.java:19)
这样的异样，然而该线程还是会执行，只不过会当做失常的用户线程执行。