1 概述
下面是维基百科上对进程和线程的解释：
进程（英语：process），是指计算机中已运行的程序。进程为曾经是分时系统的基本运作单位。在面向进程设计的系统（如早期的UNIX，Linux 2.4及更早的版本）中，进程是程序的基本执行实体；在面向线程设计的系统（如当代多数操作系统、Linux 2.6及更新的版本）中，进程本身不是基本运行单位，而是线程的容器。程序本身只是指令、数据及其组织形式的描述，进程才是程序（那些指令和数据）的真正运行实例。若干进程有可能与同一个程序相关系，且每个进程皆可以同步（循序）或异步（平行）的方式独立运行。现代计算机系统可在同一段时间内以进程的形式将多个程序加载到存储器中，并借由时间共享（或称时分复用），以在一个处理器上表现出同时（平行性）运行的感觉。同样的，使用多线程技术（多线程即每一个线程都代表一个进程内的一个独立执行上下文）的操作系统或计算机体系结构，同样程序的平行线程，可在多CPU主机或网络上真正同时运行（在不同的CPU上）。
线程（英语：thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。在Unix System V及SunOS中也被称为轻量进程（lightweight processes），但轻量进程更多指内核线程（kernel thread），而把用户线程（user thread）称为线程。
线程是独立调度和分派的基本单位。线程可以为操作系统内核调度的内核线程，如Win32线程；由用户进程自行调度的用户线程，如Linux平台的POSIX Thread；或者由内核与用户进程，如Windows 7的线程，进行混合调度。
同一进程中的多条线程将共享该进程中的全部系统资源，如虚拟地址空间，文件描述符和信号处理等等。但同一进程中的多个线程有各自的调用栈（call stack），自己的寄存器环境（register context），自己的线程本地存储（thread-local storage）。
一个进程可以有很多线程，每条线程并行执行不同的任务。
在多核或多CPU，或支持Hyper-threading的CPU上使用多线程程序设计的好处是显而易见，即提高了程序的执行吞吐率。在单CPU单核的计算机上，使用多线程技术，也可以把进程中负责I/O处理、人机交互而常被阻塞的部分与密集计算的部分分开来执行，编写专门的workhorse线程执行密集计算，从而提高了程序的执行效率。
以上的描述还是有些“学院派”，可能会让人有些难以理解。做个类比，把计算机CPU一个核心看成是一个工厂，多核就是多个工厂，进程就可以看做是工厂里的车间，但由于电力系统的问题，同一时刻只能给一个车间供电，即同一时刻只能有一个车间在进行生产工作，其他车间只能“闲着”，直到电力系统把电输送过来，然后接着干活，这个过程可以看做是进程的调度。而线程可以看做是车间里的一个一个工人，这些工人共同协作以完成任务，他们共享整个车间的“公共区域”，例如走道，休息室等（即同一进程内的线程可以共享线程的“共享资源”），但他们每个人都有自己的状态，即他们只知道自己处于什么状态，手里的任务是什么，并不知道别人的状态（即线程具有自己的堆栈，寄存器），但由于资源有限，例如只有一台设备，所以同一时刻只能有一个工人对机器进行操作，当允许操作时间结束之后或者发生意外情况时，该工人从设备中撤出来，并且记录自己工作到哪了，然后调度中心选择其他工人，让其操作设备，这个过程即线程的调度。
1.1 多线程和多进程的好处
多线程或者多进程对性能的提升是很有帮助的，试想一下，如果仅仅是单进程，那么在你使用QQ聊天的时候，就无法使用Word等软件了，有了多线程以及CPU的线程调度，QQ和Word就好像是在同时运行一样（但实际上是因为进程的切换非常迅速，人类无法在那么短的时间里做出反应，所以看起来就好像两个进程在并行的执行）。多线程也是类似的，只是多线程的并发是在进程内部的并发，如果程序大量涉及磁盘访问或者网络传输等操作，多线程就可以非常有效的提高效率，简单理解就是”人多力量大“。
虽然多线程和多进程能提高效率，但并不是一定的，因为进程切换和线程切换也是有一定开销的，如果多进程或者多线程的收益不足以抵消进程切换或者线程切换的开销，采用多进程或者多线程技术甚至会导致性能降低，得不偿失，所以不要一上来就采用多线程或者多进程编程，应该多多测试，比较，最终再确定方案。
在Java并发编程中，我们主要关注的线程以及线程间的调度，通信以及线程安全等问题，而不太关注进程，一个Java程序在启动运行后，就是一个JVM进程，进程之间的调度由JVM负责，一般的开发人员不会涉及到JVM的开发。所以，本文包括本系列后续的文章，基本上都是围绕着线程来介绍各种技术，例如线程池，锁等。
2 创建线程的三种方式
2.1 通过继承Thread的方式来创建线程
这种方式主要是创建一个类，该类继承Thread，并重写其run方法，在使用的时候，创建该类的实例，调用start方法即可启动线程，该线程运行的就是run方法里的逻辑，演示代码如下所示：
public class MyThread extends Thread {
//重写run()方法
@Override
public void run() {
System.out.println("hello, world! I'm " + Thread.currentThread().getName());
}
}
//测试类
public class Main {
public static void main(String[] args) throws InterruptedException {
MyThread myThread1 = new MyThread();
MyThread myThread2 = new MyThread();
myThread1.start();
myThread2.start();
//等待该线程结束
myThread1.join();
myThread2.join();
}
}
运行可得到类似如下输出：
hello, world! I'm Thread-0
hello, world! I'm Thread-1
这时候多运行几次，会发现有时候Thrad0在Thread1之前，有时候却是相反，这说明线程的执行顺序并不固定，这取决于线程调度。
2.2 通过实现Runnable接口来创建线程
除了继承Thread类之外，还可以通过实现Runnable接口来创建线程，Runnable接口只有一个抽象方法，即public abstract void run();实现Runnable接口的类必须实现该抽象方法，使用的时候创建Runnable实例，然后将其传入Thread类的构造函数中，最后再调用start方法启动线程即可，下面是演示代码：
public class MyRunnable implements Runnable {
@Override
public void run() {
System.out.println("hello, world! I'm " + Thread.currentThread().getName());
}
}
public class Main {
public static void main(String[] args) throws InterruptedException {
MyRunnable myRunnable = new MyRunnable();
Thread thread1 = new Thread(myRunnable);
Thread thread2 = new Thread(myRunnable);
thread1.start();
thread2.start();
thread1.join();
thread2.join();
}
}
输出结果和之前一样，不再多说。
2.3 通过实现Callable来创建线程
这种方式需要结合FutureTask来实现，因其相对其他两种方式比较复杂，所以说一下整个步骤：
- 创建一个类，实现Callable接口并实现其call方法，该方法有返回值，返回值类型是Callable的泛型参数的类型，如果不指定，返回类型可以是Object。
- 结合FutureTask，将刚刚创建的Callable实现类实例传递给构造函数，此时可以获取到FutureTask实例。
- 因为FutureTask实现了Runnable接口，所以可以传入Thread类的构造函数中，然后获取Thread类实例，并启动。
- 最后可以调用FutureTask.get()方法取得call方法的返回值，该方法是阻塞的，如果任务未完成，调用该方法的线程会被阻塞，知道任务完成。
下面是演示代码：
public class MyCallable implements Callable<Long> {
@Override
public Long call() throws Exception {
System.out.println("hello, world! I'm " + Thread.currentThread().getName());
//返回线程id
return Thread.currentThread().getId();
}
}
public class Main {
public static void main(String[] args) throws InterruptedException, ExecutionException {
MyCallable myCallable = new MyCallable();
//创建两个任务
FutureTask<Long> task1 = new FutureTask<>(myCallable);
FutureTask<Long> task2 = new FutureTask<>(myCallable);
//分别把两个任务交给不同的线程
Thread thread1 = new Thread(task1);
Thread thread2 = new Thread(task2);
thread1.start();
thread2.start();
thread1.join();
thread2.join();
//调用get()方法获取返回值
System.out.println(task1.get());
System.out.println(task2.get());
}
}
这里的FutureTask是JDK1.5才有的东西，提供异步的特性，关于异步，本文不会涉及，后续会有文章详细介绍异步相关的内容。
2.4 三种方式比较
这三种方式我个人更倾向于第二种，即实现Runnable接口的方式，在Java8中，使用lambda可以不用显式的创建Runnable实现类，使得代码更加简洁，编码效率更高。如下所示：
Runnable runnable = () -> {
System.out.println("hello, world! I'm " + Thread.currentThread().getName());
};
而第一种方式因为需要继承Thread类，所以就不能继承其他类了，这可能影响类的扩展性，不是很推荐。
第三种方式一般在异步编程中使用，是三种方式中最复杂的，如果没有异步的需求，一般也不使用这种方式。
3 Thread类
Thread类是非常重要的类，它是对Java线程的抽象，提供了丰富的操控线程（其实操控空间着实不大）的API，例如sleep()，join()，start()，isAlive()等。Thread类的很多方法都是native方法，即本地方法，其实现不是用Java语言实现的，而是用C++语言实现的（对于HotSpot虚拟机，其他的虚拟机可能不是用的C++），所以在JDK里无法查看源码，需要拿到虚拟机源码才能看到这些实现。所以这里主要是介绍几个常用的方法的功能，不涉及源码分析。
3.1 sleep()方法
sleep()方法即睡眠的意思，其参数是一个long类型的值，表示毫秒数，调用该方法的线程会停止工作，直到设置的时间结束，在停止工作的过程中，不会放弃持有的锁（如果之前有获取锁的话），这是和Object.wati()方法的主要区别之一。下面是一个演示代码：
public class Main {
public static void main(String[] args) throws InterruptedException, ExecutionException {
Runnable runnable = () -> {
System.out.println("sleep 5s");
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("hello, world! I'm " + Thread.currentThread().getName());
};
Thread thread = new Thread(runnable);
thread.start();
thread.join();
}
}
运行一下程序，发现先输出了sleep 5s的字符，过了大概5s之后，才输出hello, world! I'm***的字符。这就是sleep()的功能，很简单，不多说了。
3.2 join()方法
在以上的示例代码中，我都使用了join()方法，该方法的功能是这样的：该方法调用的所在线程需要等待工作线程执行完毕才能继续执行。
有点绕口，什么意思呢？例如现在我在main方法里调用了thread1的join方法，此时main线程就是该方法调用的所在线程，而工作线程就是thread1，所以此时的结果就是main线程需要等待thread1执行完毕，才能继续往下执行。
在上面的示例代码中，我之所以调用这个方法，目的是让main线程等待工作线程执行完毕，否则可能无法看到工作线程的输出。
3.2 中断相关方法
与中断相关的方法主要有两个：interrupt()和isInterrupted()。其中interrupt()的功能是将调用该方法的线程的中断标志位置位，而isInterrupted()的功能就是检查线程的中断标志位，当中断标志位被置位时，该方法会返回true。下面的示例代码演示了如何使用这两个方法：
public class Main {
public static void main(String[] args) throws InterruptedException, ExecutionException {
Runnable runnable = () -> {
try {
for (int i = 0; i < 5000000; i++) {
if (Thread.currentThread().isInterrupted()) {
System.out.println("interrupt occur!!");
throw new InterruptedException();
}
}
System.out.println("is it execute this statement?");
} catch (InterruptedException e) {
//在中断标志位再次置位，即表示重新中断该线程，方便上层的代码处理
Thread.currentThread().interrupt();
}
};
Thread thread = new Thread(runnable);
thread.start();
Thread.sleep(10);
thread.interrupt(); //向thread线程发送中断请求
}
}
在上面的例子中，我们在main线程调用了thread线程的interrupt()方法，表示向thread线程发送中断请求，在thread线程的逻辑是轮询检查当前线程的中断标志位（调用了isInterrupted()方法），当检查到中断标志位的时候，就抛出一个InterruptedException异常，否则会继续执行System.out.println("is it execute this statement?");该异常被catch捕获到，在catch里我们将线程的中断标志位再次置位的目的是将异常传播给上层代码，因为在run方法里无法直接抛出异常，即不能这样做：
public void run() throws InterruptedException {
//....
}
而如果仅仅是catch了，而不做一些事情的话，就只是“生吞异常”而已，这不是一个好的处理方式，比较好的处理方式就交给上层代码处理，但又无法直接抛出异常，就只能重新将线程中断标志位置位了，上层代码可以检查中断标志位，然后在上层处理该异常。
关于中断相关的知识，建议参考计算机组成原理或者操作系统相关资料。
4 线程状态
在Thread类里有一个枚举内部类，叫State，如下所示：
//省略了注释
public enum State {
NEW,
RUNNABLE,
BLOCKED,
WAITING,
TIMED_WAITING,
TERMINATED;
}
该类定义了6个枚举实例，表示线程的6个状态，下图是6种状态的状态转换图：
该图来自一篇博客，我会在最后标识出来。
4.1 New
New即初始状态，当一个线程被创建时（即new一个线程实例），线程就处于该状态。
4.2 RUNNABLE
RUNNABLE即可运行状态，注意该状态其实表示两个状态，即就绪状态和运行状态！这是很关键的，因为我相信很多朋友都看过操作系统相关的书籍，在操作系统中，它将就绪状态和运行状态用两个不同的字段表示，而Java中仅用一个字段表示，我到现在也不知道为什么Java要这样做，也许是为了实现方便？
4.3 BLOCKED
当需要进入临界区（被锁锁住的区域）时，如果线程没有争抢到锁资源，就进入了BLOCKED阻塞状态。
4.4 WAITING
等待状态，调用Object.wait()、Thread.join()或者LockSupport.park()方法的时候会进入该状态，该状态会放弃锁资源（如果之前有获取到锁资源的话）。
4.5 TIMED_WAITING
超时等待状态，调用Object.wait(long)、Thread.sleep()、Thread.join(long)或者LockSupport.parkNanos和LockSupport.parkUntil方法的时候会进入该状态，该状态和WAITING的最主要区别就是该状态有一个超时时间，当过了设置的时间，线程会自动的从该状态中“苏醒”过来。
4.6 TERMINATED
即中止状态，当线程执行完毕之后，会切换到该状态，然后再“死去”。
这里的6个状态并不一定就和操作系统的线程状态一一对应，在开始的时候，我就说过Thread类是Java对操作系统线程的一个抽象，直接的目的是为了提供方便使用的API，而不是简单的把线程一对一映射过来。
5 守护线程
Java中有两种类型的线程：普通用户线程，守护线程。守护线程的作用就是“守护”，通俗的讲就是“保姆”。只要JVM存在一个非守护线程，那么守护线程都不会停止，只有当JVM所有的非守护线程都停止时，守护线程才会随着JVM停止而停止。创建守护线程和创建普通线程是一样的，只是在创建完之后调用Thread.setDaemon(true);即可。下面是一个守护线程的示例：
public class Main {
public static void main(String[] args) {
Thread userThread = new Thread(() -> {
for (int i = 0; i < 10; i++) {
try {
Thread.sleep(400);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("user thread finished!");
});
Thread daemonThread = new Thread(() -> {
for (int i = 0; i < 100; i++) {
try {
System.out.println("damon thread : " + i);
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
daemonThread.setDaemon(true);
userThread.start();
daemonThread.start();
}
}
运行一下，输出结果大致如下所示：
daemon thread : 0
daemon thread : 1
daemon thread : 2
daemon thread : 3
daemon thread : 4
daemon thread : 5
daemon thread : 6
daemon thread : 7
user thread finished!
从输出上看出，daemon thread只运行了7次循环体，而代码中设置的是100次循环，那为什么没有执行完毕就结束了呢？因为user thread 结束了，main线程也随之结束，还有一些系统线程也随着结束，JVM不会等待守护线程执行完毕，所以看到的现象就好像守护线程被打断一样。
这里有个概念上的问题，上面说的“只要JVM存在一个非守护线程，那么守护线程都不会停止”其实并不准确，守护线程也是线程，只有当守护线程的任务是那种“永远没有尽头”的任务，上述的说法才会成立，否则守护线程执行完毕，线程照样会退出。所以，大多数守护线程的业务逻辑都是诸如“定时任务，“定时调度”，”触发式任务“等，例如GC线程就是守护线程。
注意！setDaemon()方法需要在start()方法之前调用，否则会抛出java.lang.IllegalThreadStateException异常。
5 小结
本文简单介绍了进程和线程，对于Java开发者来说，更关注的是线程，所以本文没有过多的涉及进程，如果想要了解更多关于进程的知识，建议参考操作系统经典书籍中关于进程的章节。之后还介绍了创建线程的几种方式以及Thread类的几个常用方法，最后还说了一下Java线程的6个状态以及其状态转换。本文是Java并发编程系列的第一篇，所以涉及的知识点不多，希望读者理解。
