背景
在现有的技术发展下，多线程变得越来越普遍，在处理一些耗时的任务，或者需要异步处理一些业务的时候，需要我们使用多线程来进行处理。例如在处理用户注册的时候，需要发送验证码，这个时候我们不能等到在主线程进行这个操作，因为发送验证码可能是一个比较耗时的任务，如果在主线程执行的话会进行阻塞，进而会影响到别的请求的工作。这个时候就需要我们先回复当前请求，然后新起一个线程去进行验证码的发送。
线程的生命周期
新建状态: 使用new关键字和Thread或者其子类创建了一个对象之后，该线程就处于新建状态，它会一直保持新建状态知道执行start之后
就绪状态：线程对象调用start之后，该线程就进入到就绪状态，就绪状态的线程会进入到就绪队列中，然后等待JVM中线程调度器的调度
运行状态：线程获取到CPU时间之后，就可以执行RUN方法，然后进入到运行状态中，运行状态的线程可以变成阻塞状态，死亡状态以及就绪状态
阻塞状态：在线程执行了sleep或者suspend方法之后，线程会失去CPU时间，然后进入到阻塞状态，在sleep时间到了之后，或者重新获取到CPU时间之后，可以重新进入到就绪状态。阻塞状态一般有三种：
- 等待阻塞：运行中的线程调用了wait方法，进入到等待阻塞
- 同步阻塞：获取synchronized锁失败
- 其它阻塞：例如调用了sleep或者join()等
死亡状态：线程完成任务或者其它的终止条件发生，该线程就会进入到死亡状态
创建新线程
创建线程的方式常见的有三种，继承Thread类，实现Runable接口以及使用Callable和Future配合。
继承Thread类
如要想要通过继承Thread类来实现多线程，我们需要重写其中的run方法，因为默认的run方法是没有任何内容的，并且在调用的时候通过start来开始线程，如果使用我们通过使用run方法，会在当前的线程执行run的内容，而不会新起一个线程
Thread的默认run方法
@Override
public void run() {
if (target != null) {
target.run();
}
}我们新建一个TestThread类，然后实现其中的run方法
public class TestThread extends Thread {
private String threadName;
private int totalCount;
private int count = 0;
public TestThread(String threadName, int totalCount) {
this.threadName = threadName;
this.totalCount = totalCount;
}
@Override
public void run() {
while (count < totalCount) {
count += 1;
System.out.println(count + "by " + threadName);
}
}
}然后我们新建两个TestThread，并开始执行
Thread firstThread = new TestThread("firstThread",10000);
Thread secondThread = new TestThread("secondThread",10000);
firstThread.start();
secondThread.start();通过输出我们能够看到，两个线程的执行是同时进行的
实现Runable接口
因为Runable是一个接口，所以必须要实现其中的方法
@FunctionalInterface
public interface Runnable {
/**
* When an object implementing interface <code>Runnable</code> is used
* to create a thread, starting the thread causes the object's
* <code>run</code> method to be called in that separately executing
* thread.
* <p>
* The general contract of the method <code>run</code> is that it may
* take any action whatsoever.
*
* @see java.lang.Thread#run()
*/
public abstract void run();
}我们实现Runable接口，并实现其中的run方法
public class TestRunable implements Runnable {
private int totalCount;
private int count = 0;
private String threadName;
public TestRunable( String threadName,int totalCount) {
this.totalCount = totalCount;
this.threadName = threadName;
}
@Override
public void run() {
while (count < totalCount) {
count += 1;
System.out.println(count + "by " + threadName);
}
}
}创建线程并执行
Thread firstThread = new Thread(new TestRunable("firstRunable",10000));
Thread secondThread = new Thread(new TestRunable("secondRunable",10000));
firstThread.start();
secondThread.start();
利用Callable和FutureTask
上面两种方式创建的线程，我们没有办法获取到他们的返回值，而使用Callable和FutureTask，我们能够得到线程的返回值以及进行异常的处理
需要实现Callable的call方法
@FunctionalInterface
public interface Callable<V> {
/**
* Computes a result, or throws an exception if unable to do so.
*
* @return computed result
* @throws Exception if unable to compute a result
*/
V call() throws Exception;
}实现Callable接口
import java.util.concurrent.Callable;
public class TestCallable implements Callable {
private int count = 0;
private int totalCount;
private String threadName;
public TestCallable( String threadName,int totalCount) {
this.totalCount = totalCount;
this.threadName = threadName;
}
@Override
public Object call() throws Exception {
while (count < totalCount) {
count += 1;
System.out.println(count + "by " + threadName);
}
return "done";
}
}创建FutureTask，并启动新线程去执行，这里我们需要捕获FuteTask中的异常并进行处理
TestCallable testCallable = new TestCallable("callable", 10000);
FutureTask<String> ft = new FutureTask<String>(testCallable);
new Thread(ft).start();
try {
System.out.println("start work");
System.out.println(ft.get());
} catch (Exception e) {
e.printStackTrace();
}通过结果我们能够发现在最后成功拿到了子线程的结果，但是通过输出，可能会对线程的执行顺序有点疑惑。因为start work先输出的，这里我们是否能够认为是ft.get()之后子线程才开始运行
通过给主线程加延时，我们获得以下的结果，能够发现的确是新起的一个线程，而且是在调用start之后就开始执行。
在执行了get的地方，会一直进行阻塞，直到线程进行返回才会接触阻塞。因此一般在使用的时候，我们可能需要给get设置超时时间，避免主线程阻塞过长的时间。
ft.get(1000, TimeUnit.MILLISECONDS)