《java多线程编程核心技术》读书笔记
最近读完了《java多线程编程核心技术》（高洪岩）、《Android高性能编程》（叶坤 译）、《Java RESTful Web Service实战 (第2版)》（韩陆），觉得有必要记录下。先从《java多线程编程核心技术》开始。
废话不多说，上思维导图
java多线程编程核心技术.png
1、线程常用方法
（1）继承Thread、实现Runnable接口
（2）共享数据可能会出现线程不安全问题
（3）isAlive 判断线程是否处于活动状态
（4）sleep 线程进入休眠
（5）停止线程
this.interrupted() 测试当前线程是否已经是中断状态，执行后对状态有清除为false的功能
this.isInterrupted() 测试线程Thread对象是否已经是中断状态，但不清除状态标志
可以通过Throw new Exception中断线程运行
stop方法已经不建议继续使用
（6）暂停、恢复线程
suspend、resume 该组方法有独占、不同步的缺点
yield放弃当前占用的cpu资源，但暂停时间不确定
（7）线程可以设置优先级 1～10的级别，默认5，最小1，最大10，小于1或者大于10都会抛异常
2、对象及变量的并发访问
synchronized保护的是对象
同步实例方法(同步当前对象)
int count = 0;
public synchronized void add() {
count++;
}
同步静态方法（同步当前类）
static int count = 0;
public static synchronized void add() {
count++;
}
同步代码块
（实例，同步当前对象）
int count = 0;
public void add() {
synchronized(this) {
count++;
}
}
（静态，同步当前类）
static int count = 0;
public static void add() {
synchronized(Counter.class) {
count++;
}
}
（使用单独对象作为锁）
int count = 0;
Object object = new Object();
public void add() {
synchronized(object) {
count++;
}
}
可重入性/内存可见性/死锁
volatile 变量存在于线程外部的内存空间，能保证变量是最新值，只能保证可见性，不能保证原子性，就是说不能保证变量的同步安全。
3、线程间通信
（1）等待/通知机制
wait方法是Object类的方法，必须要配合监视器（synchronized）一起使用，监视器监视的是对象。
public static void main(String[] args) {
try {
Object lock = new Object();
ThreadA threadA = new ThreadA(lock);
threadA.start();
Thread.sleep(2000);
ThreadB threadB = new ThreadB(lock);
threadB.start();
} catch (Exception e) {
e.printStackTrace();
}
}
public static class ThreadA extends Thread {
private Object lock;
public ThreadA(Object lock) {
this.lock = lock;
}
@Override
public void run() {
try {
synchronized (lock) {
System.out.println("开始 wait time:" + System.currentTimeMillis());
lock.wait();
System.out.println("结束 wait time:" + System.currentTimeMillis());
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static class ThreadB extends Thread {
private Object lock;
public ThreadB(Object lock) {
this.lock = lock;
}
@Override
public void run() {
synchronized (lock) {
System.out.println("开始 notify time:" + System.currentTimeMillis());
lock.notify();
System.out.println("结束 notify time:" + System.currentTimeMillis());
}
}
}
notifyAll 可以唤醒所有持有该对象锁的线程，让其继续执行剩余的操作。
（2）通过管道进行线程间通信（字节流/字符流）
（3）join方法的使用
public static void main(String[] args) {
try {
ThreadA thread = new ThreadA();
thread.start();
thread.join();
System.out.println("我在Thread执行完成后，执行了这个log");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
private static class ThreadA extends Thread {
@Override
public void run() {
try {
int secondValue = (int)(Math.random() * 10000);
System.out.println(secondValue);
Thread.sleep(secondValue);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
join 会释放锁，sleep 内部用的是sychronized，所以sleep不会释放锁。
（3）ThreadLocal 相关内容
ThreadLocal解决的是每个线程绑定自己的值，就想一个线程安全的盒子保存这线程的数据。
InheritableThreadLocal 可以在子线程中取得副线程传承下来的值。InheritableThreadLocal是ThreadLocal的子类。
4、Lock的使用
ReentrantLock类从jdk1.5开始进行支持。除了可以实现synchronized的的同步锁功能外，还可以实现嗅探锁定、多路分支通知等功能。
（1）基本使用
private Lock lock = new ReentrantLock();
try {
lock.lock();
.............
} catch(InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
（2）Condition实现等待/通知
Object类中的wait()相当于Condition中的await();
Object类中的wait(long timeout)相当于Condition中的await(long time, TimeUnit unit);
Object类中的notify()相当于Condition中的signal();
Object类中的notifyAll()相当于Condition中的signalAll();
public static void main(String[] args) throws InterruptedException {
// TODO Auto-generated method stub
MyService myService = new MyService();
ThreadA threadA = new ThreadA(myService);
threadA.start();
Thread.sleep(3000);
myService.signal();
}
private static class MyService {
private Lock lock = new ReentrantLock();
private Condition condition = lock.newCondition();
public void await() {
try {
lock.lock();
System.out.println("await 时间为" + System.currentTimeMillis());
condition.await();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void signal() {
try {
lock.lock();
System.out.println("signal 时间为" + System.currentTimeMillis());
condition.signal();
} finally {
lock.unlock();
}
}
}
private static class ThreadA extends Thread {
private MyService myService;
public ThreadA(MyService myService) {
this.myService = myService;
}
@Override
public void run() {
// TODO Auto-generated method stub
myService.await();
}
}
（3）公平锁 非公平锁
公平锁先来先获得锁；非公平锁先来不一定会获得锁，有可能会导致一些线程一直没获得锁。
Lock lock = new ReentrantLock(boolean isFair);
（4）各种方法
getHoldCount()、 getQueueLength()、getWaitQueueLength()
hasQueueThread()、hasQueueThreads()、hasWaiters()
isFair()、isHeldByCurrentThread()、isLocked()
lockInterruptibly()、tryLock()、tryLock(long timeout, TimeUnit unit)
awaitUninterruptibly()、awaitUntil()
（5）ReentrantReadWriteLock读写锁
有两个锁，一个读锁，一个写锁
多个读锁之间不互斥，读锁与写锁互斥，写锁与写锁互斥
O了。
