一、Java中锁
什么是锁。锁就是为了保护资源，防止多个线程同时操作资源时出错的机制。
我们先来看一下锁的类图：
ReetrantReadWriteLock读写锁是通过两个内部类——ReadLock和WriteLock实现的，其中ReadLock是共享锁，WriteLock是独占锁。这两个内部类都实现了Lock接口。
（1）、Java中的锁主要有以下几种概念：
1、同步锁
同一时刻，一个同步锁只能被一个线程访问。以对象为依据，通过synchronized关键字来进行同步，实现对竞争资源的互斥访问。
2、独占锁（可重入的互斥锁）
。什么意思呢？根据锁的获取机制，它分为“公平锁”和“非公平锁”。Java中通过ReentrantLock实现独占锁，默认为非公平锁。
3、公平锁
Java中，ReetrantLock中有一个Sync类型的成员变量sync，它的实例为FairSync类型的时候，ReetrantLock为公平锁。设置sync为FairSync类型，只需——Lock lock = new ReetrantLock(true)。
4、非公平锁
ReetrantLock默认为非公平锁，或——Lock lock = new ReetrantLock(false)。
5、共享锁
ReentrantReadWriteLock.ReadLock。即多个线程都可以读它，而且不影响其他线程对它的读，但是大家都不能修改它。CyclicBarrier， CountDownLatch和Semaphore也都是共享锁。
6、读写锁
“读取锁”用于只读操作，它是“共享锁”，能同时被多个线程获取。“写入锁”用于写入操作，它是“独占锁”，只能被一个线程锁获取。Java中，读写锁为ReadWriteLock 接口定义，其实现类是ReentrantReadWriteLock，包括内部类ReadLock和WriteLock。方法readLock()、writeLock()分别返回度操作的锁和写操作的锁。
（至于“死锁”，并不是一种锁，而是一种状态，即两个线程互相等待对方释放同步监视器的时候，双方都无法继续进行，造成死锁。）
锁的用法主要就是下面的流程：
//先得到lock
lock.lock();//然后获取锁
try {
//各种控制操作
}catch(Exception e){
}finally {
lock.unlock();//解锁
}
可以看到，这样的用法比synchronized关键字依据对象同步，要方便简单的多。
（2）LockSupport和Condition
1、LockSupport
是用来创建锁和其他同步类的基本线程阻塞原语。 LockSupport中的静态方法park() 和 unpark() 的作用分别是阻塞线程和解除阻塞线程，而不会导致死锁。演示如下：
package lock;
import java.util.concurrent.locks.LockSupport;
public class LockSupportTest {
static Thread mainThread = null;
public static void main(String[] args) {
//获取主线程
mainThread = Thread.currentThread();
//新建线程并启动
MyThread thread1 = new MyThread("thread1");
thread1.start();
//模拟线程工作开始
System.out.println(Thread.currentThread().getName() + "-----》 runs now!");
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName() + "-----》 running step " + i);
//当前线程睡眠1秒
sleepOneSecond();
if(i == 2){
System.out.println(Thread.currentThread().getName() + "-----》 now pack main thread——————————");
//让主线程阻塞
LockSupport.park();
}
}
System.out.println(Thread.currentThread().getName() + "-----》 run over!");
}
/**当前线程暂停一秒钟 */
public static void sleepOneSecond(){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
static class MyThread extends Thread {
public MyThread(String name){
super(name);
}
@Override
public void run() {
synchronized (this) {
//模拟工作开始
System.out.println(Thread.currentThread().getName() + "-----》 runs now!");
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName() + "-----》 running step " + i);
//当前线程睡眠1秒
sleepOneSecond();
}
//模拟工作结束
System.out.println(Thread.currentThread().getName() + "-----》 run over!");
}
System.out.println(Thread.currentThread().getName() + "-----》 now unpack main thread———————— ");
//解除主线程的阻塞
LockSupport.unpark(mainThread);
}
}
}
结果如下：
thread1-----》 runs now!
thread1-----》 running step 0
main-----》 runs now!
main-----》 running step 0
thread1-----》 running step 1
main-----》 running step 1
main-----》 running step 2
thread1-----》 running step 2
main-----》 now pack main thread——————————
thread1-----》 running step 3
thread1-----》 running step 4
thread1-----》 run over!
thread1-----》 now unpack main thread————————
main-----》 running step 3
main-----》 running step 4
main-----》 run over!
2、Condition
lock.newCondition();
演示懒得自己写了，参照，如下：
package LockSupportTest;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class ConditionTest {
private static Lock lock = new ReentrantLock();
private static Condition condition = lock.newCondition();
public static void main(String[] args) {
ThreadA ta = new ThreadA("ta");
lock.lock(); // 获取锁
try {
System.out.println(Thread.currentThread().getName()+" start ta");
ta.start();
System.out.println(Thread.currentThread().getName()+" block");
condition.await(); // 等待
System.out.println(Thread.currentThread().getName()+" continue");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock(); // 释放锁
}
}
static class ThreadA extends Thread{
public ThreadA(String name) {
super(name);
}
public void run() {
lock.lock(); // 获取锁
try {
System.out.println(Thread.currentThread().getName()+" wakup others");
condition.signal(); // 唤醒“condition所在锁上的其它线程”
} finally {
lock.unlock(); // 释放锁
}
}
}
}
结果如下：
main start ta
main block
ta wakup others
main continue
如上，用起来挺简单的。
二、线程池
我们先来看一下线程池的类图：
1、介绍
可见，线程池的主要是由一个Executor接口统筹的。这个接口代表一个执行者，是一个典型的命令模式的运用。这个接口只有一个方法void execute(Runnable command)，提交并执行任务。
ExecuteService顾名思义，指的是Executor的服务类，继承了Executor接口，提供了更详细的控制线程的方法。
AbstractExecutorService是一个抽象类，实现了ExecutorService大部分的方法。
ThreadPoolExecutor则继承了ExecutorService。
ForkJoinPool是JDK7新增的线程池，也是继承了这个线程类。
ScheduledExecutorService这个接口继承了ExecutorService，比ExecutorService新增了“延时”和“周期执行”的功能。
ScheduledThreadPoolExecutor这个类则实现了ScheduledExecutorService接口，且继承了ThreadPoolExecutor，新增了“延时”和“周期执行”的功能。
Executors是一个线程池的工厂类，提供一系列静态方法，用于创建各种不同功能的线程池或线程相关的对象。
而线程池的使用，最基本的就是如下：
// 创建各种线程
Thread thread1 = new MyThread();
Thread thread2 = new MyThread();
Thread thread3 = new MyThread();
// 创建线程池pool
// 将线程放入池中进行执行
pool.execute(thread1 );
pool.execute(thread2 );
pool.execute(thread3 );
// 关闭线程池
pool.shutdown();
2、ForkJoinPool
ThreadPoolExecutor、ScheduledThreadPoolExecutor、ForkJoinPool。一个是普通线程池，一个是新增了“延时”和“周期执行”的功能的线程池。那么ForkJoinPool是什么呢？
ForkJoinPool为了是解决现在、未来计算机多核的问题。ExecuteService其他实现类基本都是基于单核下执行的，解决的是并发问题，而ForkJoinPool解决的是并行问题。ExcuteService中处于后面的任务需要等待前面任务执行后才有机会执行，而ForkJoinPool会采用work-stealing模式帮助其他线程执行任务。work-stealing模式——所有在池中的线程尝试去执行其他线程创建的子任务，这样就很少有线程处于空闲状态，非常高效。
ForkJoinPool的execute方法可以传入一个ForkJoinTask对象，这个任务对象跟Runnable的不同是，ForkJoinTask被放到线程内部的队列里面，而普通的Runnable任务被放到线程池的队列里面了。
需要详细了解ForkJoinPool，可以参考。
3、Executors
Executors是一个线程池的工厂类，提供一系列静态方法，用于创建各种不同功能的线程池或线程相关的对象。
主要有如下的几个静态方法：
newCachedThreadPool() ： 创建一个具有缓存功能的线程池，系统根据需要创建线程，这些线程被缓存在线程池中。
newFixedThreadPool(int nThreads) : 创建一个可重用的，具有固定线程数的线程池。
newSingleThreadExecutor() : 创建一个只有一个单线程的线程池。
newScheduledThreadPool(int corePoolSize) : 创建具有指定数目的线程池，可以指定延时后执行任务，即使线程空闲，也被保持在线程池内。
ScheduledExecutor() : 创建一个只有一个单线程的线程池，可以指定延时后执行任务。
4、线程池的状态
线程池的状态有五种——RUNNING, SHUTDOWN, STOP, TIDYING, TERMINATED
（图片出处：）
RUNNING ： 线程池处在RUNNING状态时，能够接收新任务，以及对已添加的任务进行处理。
线程池处在SHUTDOWN状态时，不接收新任务，但能处理已添加的任务。
线程池处在STOP状态时，不接收新任务，不处理已添加的任务，并且会中断正在处理的任务。
当所有的任务已终止，ctl记录的"任务数量"为0，线程池会变为TIDYING状态。 当线程池变为TIDYING状态时，会执行钩子函数terminated()。terminated()在ThreadPoolExecutor类中是空 的，若用户想在线程池变为TIDYING时，进行相应的处理；可以通过重载terminated()函数来实现。
线程池彻底终止，就变成TERMINATED状态。
