一.JVM内存模型
Java内存模型(简称JMM)描述了Java程序中各种变量(线程共享变量)的访问规则，以及在jvm中将变量存储到内存和从内存中读取变量这样的底层细节。我们知道所有的变量都存储在内存中，而每个线程都有自己相对独立的工作内存，里面保存了该线程使用到的变量的副本(即主内存中相应变量的copy)。但是Java中又规定了线程对共享变量的所有操作都必须在自己的工作内存中进行，不能直接从内存中读写，并且不同的线程之间无法直接访问其他线程工作内存中的变量，线程间线程间变量值得传递需要通过主内存来完成。
二.线程安全
1.线程的创建
1.1.无返回值
通过Thread类创建线程;实现Runable接口;
1.2.有返回值
通过FutureTask类创建线程;实现Callable接口;
2.线程安全
2.1. 可见性
线程的交叉执行；重排序结合线程交叉执行，共享变量更新后的值没有在工作内存与主内存间及时更新会导致变量的状态不一致。那线程之间共享变量的可见性是怎么实现的呢？
共享变量可见性实现必须经过这两个步骤：
①把工作内存1中更新过的共享变量刷新到主内存中；
②将主内存中最新的共享变量的值更新到工作内存2中。
以上两个步骤也就是共享变量可见性实现的原理，Java中可见性的实现的几种方式
2.1.1.synchronize
JMM中关于synchronize有两条规定：线程解锁前，必须把共享变量的最新值刷新到主内存中；线程加锁时，将清空工作内存中共享变量的值，从而使用共享变量时需要从主内存中重新读取最新的值。那么线程执行互斥代码的过程是怎样的呢？
获得互斥锁-->清空工作内存-->从主内存拷贝变量的最新副本到工作内存中-->执行代码-->将更改后的共享变量的值刷新到主内存中-->释放互斥锁
2.1.2.volatile
volatile 通过加入内存屏障和禁止冲排序优化来实现，对volatile变量执行写操作时，会在写操作后加入一条store屏障指令；对volatile变量执行读操作时，会在读操作前加入一条load屏障指令。通俗的来说：volatile变量在每次被线程访问时，都强迫从主内存中重读改变量的值，而当该变量发生变化时，又会强迫线程将最新的值刷新到主内存中，这样任何时刻，不同的线程总能看到该变量的最新值。但是这种方式是线程不安全的，而使用synchronize是线程安全的。
2.1.3.final
final也是可以保证内存可见性的
2.2.原子变量
java.util.concurrent.atomic包中提供了相应的原子变量和原子引用;如AtomicInteger通过CAS算法来实现原子操作从而能够达到线程安全。
CAS 操作包含三个操作数 —— 内存位置（V）、预期原值（A）和新值(B)。 如果内存位置的值与预期原值相匹配，那么处理器会自动将该位置值更新为新值 。否则，处理器不做任何操作。
2.3. ThreadLocal
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。
实现原理:在ThreadLocal类中有一个Map，用于存储每一个线程的变量副本，Map中元素的键为线程对象，而值对应线程的变量副本。
2.4. 锁
内置锁：
Java提个了一种内置的锁机制来支持原子性：同步代码块(Synchronized)。
显式锁：与内置锁机制不同的是，Lock提供了一种无条件的、可轮询的、定时的以及可中断的锁获取操作，所有加锁和解锁的方法都是显示的。
ReentantLook锁：与synchronized锁一样是互斥锁,但不同的是ReentantLook可以中断一个正在等待获取该锁的线程。
读写锁：ReentantLook锁是一种互斥锁(悲观锁)；每次最多只要一个线程能持有锁，但是对于维护数据的完整性来说，互斥通常是一种过于强硬的加锁规则。但是读写锁不同,一个资源可以被多个读操作访问，或者被一个写操作访问，但是两者不能同时进行
3.线程的生命周期
初始状态-->可运行-->运行中(-->阻塞)-->死亡。
初始状态：创建线程时即为初始状态。
可运行：调用线程的start()方法。
运行中：执行run方法。
阻塞:调用sleep、join或wait方法，sleep不会让出资源。
死亡:执行完run方法。
4.线程中断
使用 thread.interrupt()方法,然后在run方法体内通过isInterrupted()判断是否需要中端线程。
三.线程池
线程池能够简化任务与线程的生命周期管理,而且还提供了一种简单灵活的方式将任务的提交与任务的执行策略解耦开来。减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。
Java提供了四种线程池,当然我们也可以自定义线程池。
newCacheThreadPool:创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
newFixedThreadPool:创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newSingleThreadExecutor:创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。 newScheduledThreadPool:创建一个定长线程池，支持定时及周期性任务执行。
四.线程安全的集合类
java.util.concurrent包中提供了一些线程安全的集合:
非阻塞集合：
ConcurrentLinkedQueue:
通过CAS算法实现线程安全
public boolean offer(E e) {
checkNotNull(e);
final Node<E> newNode = new Node<E>(e);
for (Node<E> t = tail, p = t;;) {
Node<E> q = p.next;
if (q == null) {
// p is last node
if (p.casNext(null, newNode)) {
//通过CAS算法实现线程安全
if (p != t) // hop two nodes at a time
casTail(t, newNode); // Failure is OK.
return true;
}
// Lost CAS race to another thread; re-read next
}
else if (p == q)
// We have fallen off list. If tail is unchanged, it
// will also be off-list, in which case we need to
// jump to head, from which all live nodes are always
// reachable. Else the new tail is a better bet.
p = (t != (t = tail)) ? t : head;
else
// Check for tail updates after two hops.
p = (p != t && t != (t = tail)) ? t : q;
}
}
当然还包括ConcurrentHashMap、CopyOnWriteArrayList、CopyOnWriteArraySet。
阻塞队列：
LinkedBlockingQueue
通过ReentrantLock锁来实现线程安全
public boolean offer(E e) {
if (e == null) throw new NullPointerException();
final AtomicInteger count = this.count;
if (count.get() == capacity)
return false;
int c = -1;
Node<E> node = new Node<E>(e);
final ReentrantLock putLock = this.putLock;
putLock.lock();
try {
if (count.get() < capacity) {
enqueue(node);
c = count.getAndIncrement();
if (c + 1 < capacity)
notFull.signal();
}
} finally {
putLock.unlock();
}
if (c == 0)
signalNotEmpty();
return c >= 0;
}
