1.1什么是线程？
在理解线程之前先要明白什么是进程，因为线程是进程中的一个实体。（线程是不会独立存在的）
进程：是代码在数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，线程则是进程中的一个执行路径，一个进程中至少会有一个线程，进程中的多个线程共享进程的资源。
线程：是cpu分配的基本单位。
由上图可看出，一个进程中会有多个线程，多个线程共享堆和方法区，但是每一个线程都会有自己的栈和程序计数器。
为什么要将栈和程序计数器设置为线程私有的呢？
前边说线程是cpu执行的基本单位，而cpu一般是使用时间片轮转方式轮询占用的，所以当当前线程cpu时间片使用完毕后，要让出cpu，等待下一次轮到自己的时候在调用。
那问题就来了，线程是如何知道之前执行到哪了？
程序计数器就是为了记录之前让出cpu时执行到的地址，等下次再次执行时就可以从程序计数器中获取之前执行到的位置，继续向下执行。（程序计数器是不会记录native方法执行的地址的，它只记录java代码执行的地址），而栈则是存储现场的局部变量，一遍之后再次使用
1.2线程的创建和运行
三种方式：继承Thread、实现Runnable接口、使用FuthreTask方式（实现Callable接口）。
package com.nxz.blog.otherTest;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class TestThread {
static class MyThread1 extends Thread {
@Override
public void run() {
System.out.println("extend-Thread："+this.getName());
}
}
static class MyThread2 implements Runnable {
@Override
public void run() {
System.out.println("implements-Runnable:"+Thread.currentThread());
}
}
static class MyThread3 implements Callable<String> {
@Override
public String call() throws Exception {
System.out.println("implements-Callable:"+Thread.currentThread());
return "Callable接口";
}
}
public static void main(String[] args) {
MyThread1 t1 = new MyThread1();
t1.start();
Thread t2 = new Thread(new MyThread2());
t2.start();
FutureTask<String> futureTask = new FutureTask<>(new MyThread3());
new Thread(futureTask).start();
try {
// 阻塞，等待执行完毕，并返回结果
String res = futureTask.get();
System.out.println(res);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
System.out.println("main-Thread");
}
}
上述代码执行结果：
extend-Thread:Thread-0 implements-Runnable:Thread[Thread-1,5,main] implements-Callable:Thread[Thread-2,5,main] Callable接口 main-Thread
创建线程后会调用start方法，代表当前线程已经处于就绪状态（也就是说该线程已经获取了除cpu资源外的其他资源，等待cpu执行时间片），当获取了cpu资源后，该线程才处于运行状态，一旦run方法（对于extent Thread来说）执行完毕，该线程就处于终止状态。
使用继承的好处：在run方法内可以直接使用this来获取当前线程（而另两个的this则没有getName等一些方法），而不需要Thread.currentThread()。
1.3线程通知和等待
以下三个方法都是Object类的方法，为所有对象公用
①wait()
当一个线程调用wait()方法后，该线程就会被阻塞挂起，知道被notify/notifyAll调用或者其他线程调用了intercept方法中断了该线程
②wait(long timeout)
表上边一个多了一个超时时间，在等待期间如果没有其他线程唤醒（notify/notifyAll）该线程，该线程仍然会在超过timeout时间后自动返回
③wait(long timeout, int nanos) ：两个参数，毫秒timeout，纳秒nanos，其内部还是调用的wait(long timeout)方法，只不多对于第二个参数纳秒，如果其范围是大于0，小于一百万的话（1毫秒= 100 0000纳秒），则将timeout加一秒
public final void wait(long timeout, int nanos) throws InterruptedException {
if (timeout < 0) {
throw new IllegalArgumentException("timeout value is negative");
}
if (nanos < 0 || nanos > 999999) {
throw new IllegalArgumentException(
"nanosecond timeout value out of range");
}
if (nanos > 0) {
timeout++;
}
wait(timeout);
}
④notify()/notifyAll()
唤醒在同一个共享变量上等待的线程，区别：一个唤醒一个，一个唤醒所有
需要注意的：
*虚假唤醒：
一个线程可以从挂起状态变为可以运行状态（也就是被唤醒），即使该线程没有被其他线程调用notify()、notifyAll()方法进行通知，或者被中断，或者等待超时，这就是虚假唤醒
（在java并发编程之美中这样描述的，感觉不太清楚，找了其他资料有的是这样描述的：在多核处理器下，其他线程的信号可能会唤醒多个线程（阻塞在同一个条件变量上的线程），结果就是，多个被唤醒的线程，前一个执行代码逻辑后，另外的线程再次执行同样的代码后会出现问题）
例子：在下边代码中分别为生产者和消费者，假如在一个生产者和一个消费者的情况下（也就是单线程），是没有问题的，不存在虚假唤醒，假如在多线程环境下，当一个生产者完成之后，调用notifyAll方法后，会唤醒其他生产者和所有的消费者，当第一个消费者消费完成之后，在有消费者消费，此时就会出现问题（也就是出现了虚假唤醒），解决该问题的方法，就是将消费者和生产者中的条件判断if(queue.size() == 1) 和if(queue.isEmpty()) 改为 while( queue.size() == 1) 和while( queue.isEmpty() ) ，即改为循环判断，当被唤醒是，每一个线程都重新判断是否符合条件
static Queue queue;
static class ProductThread extends Thread {
@Override
public void run() {
synchronized (queue) {
if (queue.size() == 1) {// 假设队列最多存一个对象
try {
queue.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
queue.add(new Object());
queue.notifyAll();
}
}
}
static class ConsumerThread extends Thread {
@Override
public void run() {
synchronized (queue) {
if (queue.isEmpty()) {
try {
queue.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
queue.poll();
queue.notifyAll();
}
}
}
1.4等待线程执行完毕 的join方法
当调用join方法（该方法属于Thread类）时，就会等待线程执行完毕后，在继续向下运行
例子：
package com.nxz.blog.otherTest;
public class TestThread002 {
static class MyThread extends Thread{
@Override
public void run() {
System.out.println("myThread");
}
}
public static void main(String[] args) throws InterruptedException {
MyThread t1 = new MyThread();
t1.setName("myThread");
t1.start();
// 如果注释掉 下边代码的话，main方法的输出应该会是 先main-thread 然后再试mythread，
// 放开的话 main主线程就会等待t1线程执行完毕后，在向下运行
t1.join();
System.out.println("main-thread");
}
}
1.5sleep方法休眠
Thread中的静态方法sleep()，当一个线程调用了sleep方法后，会短暂的让出cpu执行权（也就是不参与cpu的调度），但是线程拥有的锁等资源是不释放的，这一点和wait方法不同
1.6让出cpu执行权yield方法
Thread中的静态方法yield()，当一个线程调用了Thread.yield()时，表名当前线程放弃cpu的使用权，yield之后，当前线程处于就绪状态。线程调度器会从包括该线程的所有线程中随机选出一个线程分配cpu执行时间片。
1.7中断线程
java中的线程中断是一种线程间的协作模式，通过设置线程的中断标志并不能直接中断线程，而是被中断的线程根据中断标志自行处理。
void interruupt() ：中断线程
boolean isInterrupted() ：检测当前现车鞥是否中断（调用isInterrupted()方法的实例的中断标志）
boolean interrupted()： 检测当前线程是否被中断（内部是获取当前线程的中断标志而不是调用interruupted()方法的实例的中断标志）
1.8线程的上下文切换
在多线程编程中线程的个数一般都是大于cpu的个数的，而每个cpu在同一时刻只能被一个线程使用。为了让用户感觉实在同时执行，cpu资源的分配采用时间片轮询的侧率。
上下文切换：就是一个线程使用完时间片之后，将cpu资源让给其他线程使用，并且线程状态转变为就绪状态。
1.9线程死锁
多个线程在执行过程中，因争夺资源而造成相互等待的状态，如没有其他因素，线程会一直等待，而无法继续运行。
死锁产生的条件：1、互斥 2、请求并持有资源 3、不可剥夺 4、环路等待
1.10守护线程和用户线程
守护线程：类似垃圾回收线程
用户线程：main函数启动，就是一个简单的用户线程
jvm停止的时机：在用户线程全都执行完毕后，jvm就会停止（无论有没有守护线程）
1.11ThreadLocal
当创建了一个ThreadLocal变量之后，多个线程操作这个变量时，实际上操作的是自己本地内存里的变量，也就是说每个线程都会复制一份变量到自己的本地内存。
THreadLocal是怎么和线程关联起来的呢？
ThreadLocal其实就是一个空壳，当调用ThreadLocal的set或get方法时，其内部是通过set方法把value放到调用线程的threadlocals变量中（ThreadLocal.threadLocalMap），也就是说本地变量不是存在ThreadLocal实例中，而是存入Thread中的threadlocals中。
public void set(T value) {
Thread t = Thread.currentThread(); // 当调用ThreadLocal的set方法时，其实是获取的是当前线程Thread中的ThreadLocalMap变量，如果变量为null，则新建一个ThreadLocalMap，如果变量存在，则之间将当前线程和value存入定制的map中（ThreadLocalMap）
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}
// 从源码getMap中可以看出，其实获取的是当前线程中的threadLocals变量
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
public T get() { // ThreadLocal的get方法，同样是获取的是当前线程Thread中的threadLocals变量（也就是ThreadLocalMap类型的数据）
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
return setInitialValue();
}