需要了解的概念
并发和并行
并发侧重于任务的交替执行，同一时间只能执行一个任务；而并行是任务的同时执行，统一时间可以有多个任务被执行。
单核CPU与多核CPU下任务表现分别为并发与并行。
临界区
临界区用于表示一种公共资源或是共享数据，可以被多个线程使用，但是同一时间内，只能有一个线程在使用它。一旦临界区资源被占用，其他线程要想使用这个资源，则必须等待。
死锁、饥饿和活锁
死锁
指两个或两个以上的进程（或线程）在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。
饥饿
饥饿是指线程因为种种原因无法获取所需要的资源，导致一直无法执行。比如它的线程优先级可能太低，而高优先级的线程不断抢占他需要的资源。
活锁
当其他线程要使用临界资源时，如果线程主动放弃资源供其他线程使用，而其它线程也主动放弃来使其他线程使用。这样你让我，我让你，最后无论哪个线程都无法使用资源。
线程的状态
Java 线程有6种状态，其定义在Thread.State中：
public class Thread implements Runnable {
/**
* A thread can be in only one state at a given point in time.
* These states are virtual machine states which do not reflect any operating system thread states.
*/
public enum State {
/**
* Thread state for a thread which has not yet started.
*/
NEW,
/**
* Thread state for a runnable thread. A thread in the runnable
* state is executing in the Java virtual machine but it may
* be waiting for other resources from the operating system such as processor.
*/
RUNNABLE,
/**
* Thread state for a thread blocked waiting for a monitor lock.
* A thread in the blocked state is waiting for a monitor lock to enter a synchronized block/method or
* reenter a synchronized block/method after calling {@link Object#wait() Object.wait}.
*/
BLOCKED,
/**
* Thread state for a waiting thread.
* A thread is in the waiting state due to calling one of the
* following methods:
* <ul>
* <li>{@link Object#wait() Object.wait} with no timeout</li>
* <li>{@link #join() Thread.join} with no timeout</li>
* <li>{@link LockSupport#park() LockSupport.park}</li>
* </ul>
*
* <p>A thread in the waiting state is waiting for another thread to
* perform a particular action.
*
* For example, a thread that has called <tt>Object.wait()</tt>
* on an object is waiting for another thread to call
* <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
* that object. A thread that has called <tt>Thread.join()</tt>
* is waiting for a specified thread to terminate.
*/
WAITING,
/**
* Thread state for a waiting thread with a specified waiting time.
* A thread is in the timed waiting state due to calling one of
* the following methods with a specified positive waiting time:
* <ul>
* <li>{@link #sleep Thread.sleep}</li>
* <li>{@link Object#wait(long) Object.wait} with timeout</li>
* <li>{@link #join(long) Thread.join} with timeout</li>
* <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
* <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
* </ul>
*/
TIMED_WAITING,
/**
* Thread state for a terminated thread.
* The thread has completed execution.
*/
TERMINATED;
}
}NEW：初始状态，线程被构建，但是还没有调用start方法;
RUNNABLED：运行状态，JAVA 线程把操作系统中的就绪和运行两种状态统一称为RUNNABLED;
BLOCKED：阻塞状态，例如进入同步锁中；
WAITING：等待状态，例如调用Object.wait、Thread.join(with no timeout)、LockSupport.park等；
TIME_WAITING：超时等待状态，例如调用Thread.sleep以及带超时间的Object.wait、Thread.join等，超时以后自动返回;
TERMINATED：终止状态，表示当前线程执行完毕。
示意图如下：
线程的基本使用
java中多线程使用方式主要为继承Thread类、实现Runnable接口、实现Callable接口。如果使用线程池，可以使用ExecutorService等。
线程的新建
继承Thread
示例：
class ThreadDemo extends Thread {
public void run() {
System.out.println("run");
}
public static void main(String[] args) {
ThreadDemo threadDemo = new ThreadDemo();
threadDemo.start();
}
}Thread类本质上是实现了Runnable接口的一个实例。启动线程的唯一方法就是通过Thread类的 start()实例方法：
public class Thread implements Runnable {
...
/**
* Causes this thread to begin execution; the Java Virtual Machine
* calls the <code>run</code> method of this thread.
* <p>
* The result is that two threads are running concurrently: the
* current thread (which returns from the call to the
* <code>start</code> method) and the other thread (which executes its
* <code>run</code> method).
* <p>
* It is never legal to start a thread more than once.
* In particular, a thread may not be restarted once it has completed
* execution.
*/
public synchronized void start() {
...
try {
start0();
started = true;
} finally {...}
}
}start()中最终调用了start0()，而start0()是一个native方法，它会启动一个新线程，并在该线程中执行run方法。
start()执行涉及两个线程：当前线程(threadDemo在该线程中调用自己的start())和新的线程(jvm会在该线程中调用run方法，并使其在在该线程中执行)。
值得注意的是，threadDemo直接调用run()不会开启新的线程，因为没有最终调用start0()，此时仅是在当前线程中普通的方法调用；threadDemo直接调用start()则会开启新线程，并让jvm调用run方法在开启的线程中执行。
另外，多次启动线程是不合法的，尤其是线程执行完成后不能重新启动。
实现Runnable接口
如果自己的类已经继承了其它类，无法直接继承Thread，此时可以实现Runnable接口：
class ThreadDemo implements Runnable {
public void run() {
System.out.println("run");
}
public static void main(String[] args) {
ThreadDemo threadDemo = new ThreadDemo();
new Thread(threadDemo).start();
}
}实现方式虽然变了，但是最终还是要调用start()。
实现Callable接口
当需要新线程提供返回值给主线程时，例如主线程需要依赖该返回值进行后续的处理，此时可以使用Callable方式：
class ThreadDemo implements Callable {
public String call() {
return "run";
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
FutureTask<String> futureTask = new FutureTask<>(new ThreadDemo());
new Thread(futureTask).start();
String result = futureTask.get();
System.out.println(result);
}
}Callable和Runnable
Callable方式属于Executor框架的功能类，相对于runable体系：
1. callable在任务结束时可以提供返回值，runnable无法提供；
2. run()不能抛出任何检查型异常，但是，非检查型异常会导致线程终止;
3. 运行callable可以拿到future，future能监视目标线程调用call方法的情况，当调用future的get方法以获取结果时，当前线程就会被阻塞，直到call方法结束返回结果。对于第二条：
检查型异常(Checked Exception)：指编译器要检查这类异常，这类异常的发生通常是难以避免的，编译器强制让开发者去解决掉这类异常(通过throws或try-catch)，所以称为检查型异常。如果不处理这类异常则不会通过编译。
例如
FileNotFoundException，编译器认为文件找不到是不可避免的，如果不处理这些异常，程序将来肯定会出错，此时编译器会提示捕获并处理这种可能发生的异常，不处理就不能通过编译。非检查型异常(Unchecked Exception)：指编译器不会检查这类异常，编译器认为此类异常不是必须处理的，因此即使不处理这类异常，编译器也不会给出错误提示。
例如数组越界、空指针异常等。
run()不能抛出检查型异常，因为接口定义中就没有throws异常：
@FunctionalInterface
public interface Runnable {
public abstract void run();
}并且throws是向上级调用者抛出异常，主线程调用start()后，是由jvm去调用run()方法的，因此run()的最终调用者是jvm。
但是线程依然有可能抛出unchecked exception，此类异常抛出时会导致线程终止，但是对于主线程和其他线程则完全感知不到该异常的抛出(当然也无法法catch到该异常)，且该异常的抛出对主线程和其他线程完全没有影响。
因此，对于Runnable体系的线程，我们不能捕获在线程中出现的异常，因此无论是checked exception还是unchecked exception，run方法内进行try-catch并处理掉，即：
class ThreadDemo0 implements Runnable {
public void run() throws Exception { // throws Exception会导致编译不通过
System.out.println(1 / 0);
}
public static void main(String[] args) {
try {
ThreadDemo0 threadDemo0 = new ThreadDemo0();
new Thread(threadDemo0).start();
} catch (Exception e) {
e.printStackTrace(); // 无法catch到除0异常
}
}
}java5之后，我们可以通过Executor来解决run()抛出的unchecked exception问题。Thread.UncaughtExceptionHandler是java5的新接口，它允许在每一个Thread对象上添加一个异常处理器：
public class Thread implements Runnable {
/**
* Interface for handlers invoked when a <tt>Thread</tt> abruptly
* terminates due to an uncaught exception.
* <p>When a thread is about to terminate due to an uncaught exception
* the Java Virtual Machine will query the thread for its
* <tt>UncaughtExceptionHandler</tt> using
* {@link #getUncaughtExceptionHandler} and will invoke the handler's
* <tt>uncaughtException</tt> method, passing the thread and the
* exception as arguments.
* If a thread has not had its <tt>UncaughtExceptionHandler</tt>
* explicitly set, then its <tt>ThreadGroup</tt> object acts as its
* <tt>UncaughtExceptionHandler</tt>. If the <tt>ThreadGroup</tt> object
* has no
* special requirements for dealing with the exception, it can forward
* the invocation to the {@linkplain #getDefaultUncaughtExceptionHandler
* default uncaught exception handler}.
*
* @see #setDefaultUncaughtExceptionHandler
* @see #setUncaughtExceptionHandler
* @see ThreadGroup#uncaughtException
* @since 1.5
*/
@FunctionalInterface
public interface UncaughtExceptionHandler {
/**
* Method invoked when the given thread terminates due to the
* given uncaught exception.
* <p>Any exception thrown by this method will be ignored by the
* Java Virtual Machine.
*/
void uncaughtException(Thread t, Throwable e);
}
}当线程因未捕获的异常而将要被终止时，则jvm首先查询当前线程是否有UncaughtExceptionHandler处理器，如果有则使用该处理器的uncaughtException()来处理，并将当前线程及其异常作为参数传递过去；
如果没有该处理器，则查看当前线程所在线程组是否设置了UncaughtExceptionHandler，如果已经设置则使用该线程组的UncaughtExceptionHandler来处理；
否则，通过getUncaughtExceptionHandler获取默认处理器：
public UncaughtExceptionHandler getUncaughtExceptionHandler() {
return uncaughtExceptionHandler != null ?
uncaughtExceptionHandler : group;
}如果上述处理器都不存在，那么jvm将直接在console中打印Exception的StackTrace信息。
线程的停止
线程停止不能使用Thread.stop()，因为该方法是暴力停止，如果业务执行到一半被stop()终止，则可能会导致数据的不一致。
正确的停止方式应该由实际业务决定，例如：
class ThreadDemo0 implements Runnable {
private static volatile boolean stop = false;
private static volatile int i = 0;
public void run() {
while(!stop) {
System.out.println(i++);
}
}
public static void main(String[] args) {
new Thread(new ThreadDemo0()).start();
while(true) {
if (i == 5) {
stop = true;
}
}
}
}实际上Thread提供了线程中断相关的API：
public void Thread.interrupt();
public boolean Thread.isInterrupted();
public static boolean Thread.interrupted();interrupt()用于通知线程中断，也就是设置中断标志位，中断标志位表示当前线程已经被中断了。isInterrupted()用于判断当前线程是否被中断。静态方法interrupted()也是用于判断当前线程的中断状态，但同时会清除当前线程的中断标志位。
class ThreadDemo0 implements Runnable {
private static volatile int i = 0;
public void run() {
while(!Thread.currentThread().isInterrupted()) {
System.out.println(i++);
}
}
public static void main(String[] args) {
Thread thread = new Thread(new ThreadDemo0());
thread.start();
while(true) {
if (i == 5) {
thread.interrupt();
break;
}
}
}
}当发生异常时，interrupt标志位会被复位。
线程等待和通知
wait()和notify()、notifyAll()用于多线程之间的协作，这两个方法都属于Object类，这意味着任何对象都能调用这两个方法。
当在一个对象A调用wait()方法后，当前线程就会在这个对象上等待，直到其他线程调用了对象A的notify()或notifyAll()为止。
如果一个线程调用了object.wait()，那么该线程则进入object对象的等待队列。这个队列中可能会存在多个线程，当object.notify()被调用时，它就会从这个等待队列中随机选择一个线程并将其唤醒。如果执行object.notifyAll()则唤醒队列中所有线程。
需要注意的是，wait()、notify()、notifyAll()必须在synchronized代码块中使用，方法执行前都必须获取目标对象的监视器，当wait()执行时会释放当前的监视器并使得当前线程进入阻塞队列，当notify()被调用时，首先要获取到object的监视器，然后才能去唤醒其他线程。
示例：
class ThreadDemo {
final static Object OBJECT = new Object();
public static class T1 extends Thread {
public void run() {
synchronized (OBJECT) {
try {
System.out.println("t1 start");
OBJECT.wait();
System.out.println("t1 end");
} catch (InterruptedException e) {}
}
}
}
public static class T2 extends Thread {
public void run() {
synchronized (OBJECT) {
System.out.println("t2 start");
OBJECT.notify();
System.out.println("t2 end");
try {
Thread.sleep(2000);
} catch (Exception e) {}
}
}
}
public static void main(String[] args) {
new T1().start();
new T2().start();;
}
}上述代码执行时，t1被唤醒后并不能立即执行，因为t2线程sleep了2秒，在这2s内t2并未释放object的监视器，所以在t2线程sleep了2s后，才会输出t1 end。
这三个方法必须在synchronized代码块中执行，因为这些操作都和监视器相关，wait必须要知道获取谁的监视器，而notify需要知道去唤醒等待在哪里的线程，而synchronized可以提供这个监视器。
监视器(monitor)和锁(lock)的关系：
在jvm中，锁的实现方式就是monitor；
entermonitor就是获得某个对象的lock(owner是当前线程)；
leavemonitor就是释放某个对象的lock。简单的认为，在object中，monitor就是lock。
线程挂起和继续
线程的挂起和继续执行的方法分别是suspend()和resume()，被挂起的线程，必须要等到resume()操作后才能继续执行。但这两个方法已经被废弃了。
因为suspend()在导致线程暂停的同时，并不会去释放任何锁资源。此时，其他任何线程想要访问被它占用的锁时，都会被阻塞。直到对应的线程上进行了resume()操作，被挂起的线程才能继续。但是，如果resume()操作意外地在suspend()前就执行了，那么被挂起的线程可能很难有机会被继续执行。并且它所占用的锁也不会被释放。
而且，对于被挂起的线程，从它的线程状态上看，居然还是Runnable，这也会严重影响我们对系统当前的判断。
线程join和yield
join和yield的部分源码：
public class Thread implements Runnable {
/**
* Waits for this thread to die.
*/
public final void join() throws InterruptedException {
join(0);
}
/**
* Waits at most {@code millis} milliseconds for this thread to
* die. A timeout of {@code 0} means to wait forever.
*/
public final synchronized void join(long millis)
throws InterruptedException {
...
if (millis == 0) {
while (isAlive()) {
wait(0);
}
} else {
while (isAlive()) {
...
wait(delay);
...
}
}
}
/**
* A hint to the scheduler that the current thread is willing to yield
* its current use of a processor. The scheduler is free to ignore this
* hint.
*/
public static native void yield();
}join
当前线程调用其他线程的join方法，会阻塞当前线程，直到其他线程执行完毕，才会继续执行。
join()表示无限期的等待，而join(long millis)则指定等待的最大时间，如果超过最大时间则不再等待该线程，继续执行。
从源码中可以发现，join()方法是通过wait()实现的，而join(long millis)则是通过wait(long timeout)实现的。当millis为0 时，会进入while(isAlive())循环，并且只要子线程是活跃的，宿主线程就不停的等待。
join方法会让宿主线程交出CPU执行权，并放弃占有的锁。
yield
调用yield()会让当前线程交出CPU资源，但是交出CPU资源后，该线程仍然会参与争夺下一轮CPU的使用权。但是，yield()不能控制具体的交出CPU的时间。
调用yield()方法并不会让线程进入阻塞状态，也不会释放锁，而是让线程重回就绪状态，它只需要等待重新得到CPU的执行权就又能继续执行了。