第2章 对象及变量的并发访问
2.1 synchronized同步方法
方法内的变量为线程安全：
方法内部的变量是线程私有的
方法中有一个变量num，后面对它赋值
两个线程同时调用这个方法，对其赋不同的值，不会出现非线程安全的问题
实例变量非线程安全：
多个线程共同访问一个对象中的实例变量，则会出现非线程安全的问题
对方法加上synchrongized，则可以解决该问题
多个对象多个锁：
两个线程访问不同对象的方法，则是线程安全的
即使获得了锁，也不会同步，因为不是用一个对象的锁
A线程先持有object对象的Lock锁，B线程可以以异步的方式调用object对象中的非synchronized类型的方法。
A线程先持有object对象的Lock锁，B线程如果在这时调用object对象中的synchronized类型的方法则需等待，也就是同步。
synchronized锁重入：
关键字synchronized拥有锁重入的功能，也就是在使用synchronized时，当一个线程得到一个对象锁后，再次请求此对象锁时是可以再次得到该对象的锁的。
这也证明在一个synchronized方法/块的内部调用本类的其他synchronized方法/块时，是永远可以得到锁的。
可重入锁也支持在父子类继承的环境中。
出现异常，锁自动释放
同步不具有继承性
2.2 synchronized同步语句块
synchronized声明方法在某些情况下是有弊端的，比如A线程调用同步方法执行一个长时间的任务，那么B线程则必须等待较长的时间，在这种情况下可以使用同步语句块来解决。
当一个线程访问object的一个synchronized同步代码块时，另一个线程仍然可以访问该object对象中的非synchronized（this）同步代码块。
当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对同一个object中所有其他synchronized（this）同步代码块的访问将被堵塞，这说明synchronized使用的“对象监视器”是一个。
如果使用同步代码块锁定非this对象，则不会与其他硕this同步方法争抢this锁。
synchronized加到静态方法上，是给Class类加锁，加到非静态方法上，是给对象加锁。
程序设计时要避免双方互相持有对方的锁的情况，避免死锁。
2.3 volatile关键字
一个线程执行while（flag）的无限循环，主线程再将flag置为false，还是有可能出现死循环，解决办法是用volatile
在JVM -server模式中，为了线程运行的效率，线程一直在私有堆栈中获取flag的值为true，主线程修改的是公共堆栈中的flag
使用volatile关键字，强制从公共内存中读取变量的值
关键字synchronized和volatile进行一下比较：
关键字volatile只能修饰变量，而synchronized可以修饰方法，以及代码块，随着JDK新版本的发布，synchronized关键字在执行效率上得到很大的提升，在开发中时用synchronized关键字的比率还是比较大的。
多线程访问volatile不会发生堵塞，而synchronized会出现堵塞。
volatile能保证数据的可见性，但不能保证原子性，而synchronized可以保证原子性，也可以间接保证可见性，因为它会将私有内存和公共内存中的数据做同步。
关键字volatile解决的是变量在多个线程之间的可见性，而synchronized关键字解决的是多个线程之间访问资源的同步性。
使用原子类进行i++ ：
除了在i++操作是使用synchronized关键字实现同步外，还可以使用AtomicInteger原子类进行实现。
原子操作是不能分割的整体，没有其他线程能够中断或检查正在原子操作中的变量。一个原子类型就是一个原子操作可用的类型，它可以在没有锁的情况下做到线程安全。
关键字synchronized可以保证在同一时刻，只有一个线程可以执行某一个方法或某一个代码块。
它包含两个特征：互斥性和可以见性。同步synchronized不仅可以解决一个线程看到的对象处于不一致的状态，还可以保证进入同步方法或者同步代码块的每个线程，都看到由同一个锁保护之前所有的修改效果。
第3章 线程间通信
3.1 等待/通知机制
wait()：
在调用wait()方法之前，线程必须获得该对象的对象级别锁，即只能在同步方法或同步块中调用wait()方法。
wait()方法是Object类的方法，该方法用来将当前线程置入“预执行队列”中，并且在wait()所在的代码行处停止执行，直到接到通知或被中断为止。
在执行wait()方法后，当前线程释放锁。（sleep不会释放锁。）
notify()：
方法notify()也要在同步方法或同步块中调用，即在调用前，线程也必须获得该对象的对象级别锁。
该方法用来通知那些可能等待该对象锁的其他线程，如果有多个线程等待，则由线程规划器随机挑选出其中一个呈wait状态的线程，对其发出通知notify，并使它等待获取该对象的对象锁。
在执行notify()方法后，当前线程不会马上释放该对象锁，要等到执行notify()方法的线程将程序执行完，也就是退出synchronized代码块后，当前线程才会释放锁，而呈wait状态所在的线程才可以获取该对象锁。
总结：
wait 使线程停止运行，notify 使停止的线程继续运行。
wait ()方法可以使调用该方法的线程释放共享资源的锁，从运行状态退出，进入等待状态，直到再次被唤醒。
notify() 方法可以随机唤醒等待队列中等待同一共享资源的一个线程，并使该线程退出等待状态，进入可运行状态。
notifyAll() 方法可以随机唤醒等待队列中等待同一共享资源的所有线程，并使这些线程退出等待状态，进入可运行状态。
线程状态：
新创建一个线程对象后，调用它的 start() 方法，系统会为此线程分配 CPU 资源，使其处于 Runnable（可运行）状态，如果线程抢占到 CPU 资源，此线程就会处于 Running （运行）状态
Runnable 和 Running 状态之间可以相互切换，因为线程有可能运行一段时间后，有其他优先级高的线程抢占了 CPU 资源，此时线程就从 Running 状态变成了 Runnable 状态。
线程wait()之后，调用线程对象的interrupt()方法会出现异常。
wait(long)：等待某一时间内是否有线程对锁进行唤醒，超过这个时间则自动唤醒。
生产者消费者问题：
用wait和notify的话，注意使用循环和notifyAll
通过管道进行线程间通信：
字节流：PipedInputStream，PipedOutputStream
字符流：PipedReader，PipedWriter
3.2 join
使所属的线程对象x正常执行run()，当前线程z无限期阻塞，等待线程x被销毁后再执行线程z。
join 方法具有使线程排队运行的作用，有些类似同步的运行效果。
join 与 synchronized 的区别是：join 在内部使用 wait() 方法进行等待，而 synchronized 关键字使用的是 “对象监视器” 原理做为同步。
在 join 过程中，如果当前线程对象被中断，则当前线程出现异常。
方法 join(long) 中的参数是设定等待的时间。
join(long)在内部是使用wait(long)实现的，所以这个方法会释放锁，而sleep(long)不会释放锁。
t.join()方法阻塞调用此方法的线程(calling thread)，直到线程t完成，此线程再继续；
通常用于在main()主线程内，等待其它线程完成再结束main()主线程。例如：
1 public class JoinTester01 implements Runnable { 2 3 private String name; 4 5 public JoinTester01(String name) { 6 this.name = name; 7 } 8 9 public void run() { 10 System.out.printf("%s begins: %s ", name, new Date()); 11 try { 12 TimeUnit.SECONDS.sleep(4); 13 } catch (InterruptedException e) { 14 e.printStackTrace(); 15 } 16 System.out.printf("%s has finished: %s ", name, new Date()); 17 } 18 19 public static void main(String[] args) { 20 Thread thread1 = new Thread(new JoinTester01("One")); 21 Thread thread2 = new Thread(new JoinTester01("Two")); 22 thread1.start(); 23 thread2.start(); 24 25 try { 26 thread1.join(); 27 thread2.join(); 28 } catch (InterruptedException e) { 29 // TODO Auto-generated catch block 30 e.printStackTrace(); 31 } 32 33 System.out.println("Main thread is finished"); 34 } 35 36 }
3.3 ThreadLocal
解决的是变量在不同线程间的隔离性，也就是不同线程拥有自己的值。
3.4 InheritableThreadLocal
可以在子线程中取得父线程继承下来的值。
第4章 Lock 的使用
4.1 使用 ReentrantLock 类
使用下面代码获取ReenTrantLock对象lock：
private Lock lock = new ReentrantLock();
调用lock.lock()方法可以对代码进行加锁，调用lock.unlock()方法对代码进行解锁。
调用了lock()方法代码的线程会持有“对象监视器”，其他线程只有等待锁被释放时再次争抢，效果跟使用synchronized关键字一样，线程间还是顺序执行的。
Condition：
类ReentrantLock实现等待/同步功能，需要借助于condition对象。
Condition类具有很好的灵活性，可以实现多路通知功能：在一个Lock对象中创建多个Condition（对象监视器）实例，线程对象可以注册在指定的Condition中，从而有选择性地进行线程通知，在调度线程上更灵活。
在使用notify()/notifyAll()方法进行通知时，被通知的线程是由JVM随机选择的，但使用ReentrantLock结合Condition类是可以实现前面介绍过的“选择性通知”，这个功能是常用，且在Condition中是默认的。
synchronized相当于整个Lock对象中只有一个单一的condition对象，所有线程都注册在他一个对象上。
Object类中的wait()方法相当于Condition类中的await()方法。
Object类中的wait(long timeout)方法相当于Condition类中的await(long time, TimeUnit unit)方法。
Object类中的notify()方法相当于Condition类中的single()方法。
Object类中的notifyAll()方法相当于Condition类中的singleAll()方法。
公平锁与非公平锁：
公平锁：标识线程获取锁的顺序是按照线程加锁的顺序来分配的，即先来先得的FIFO先进先出顺序。
非公平锁(默认)：一种线程抢占机制，是随机获取锁的，和公平锁不一样的就是先来的不一定先得到锁，这个方法可能会导致某些线程一直拿不到锁，自然不公平。
创建的方式就是：
private Lock lock = new ReentrantLock(Boolean flag);
flag为true就是公平锁，flag为false就是非公平锁。
ReentrantLock类的API：
int getHoldCount() ：查询当前线程保持此锁定的个数，也就是调用lock()方法的次数。
int getQueueLength()：返回正等待获取此锁定线程估计数。
int getWaitQueueLength(Condition condition)：返回等待与此锁定相关的给定条件Condition的线程估计数。
比如有5个线程，每个线程都执行了同一个condition对象的await()方法，则调用getWaitQueueLength()返回的值就是5。
boolean hasQueuedThread(Thread thread)：查询指定的线程是否正在等待获取此锁定。
boolean hasQueuedThreads()：查询是否有线程正在等待获取此锁定。
boolean hasWaiters(Condition condition)：查询是否有线程正在等待与此锁定有关的condition条件。
boolean isFair()：判断是不是公平锁
boolean isHeldByCurrentThread()：查询当前线程是否保持此锁定
boolean isLocked()：查询此锁定是否由任意线程保持
void lockInterruptibly()：如果当前线程未被中断（不处于中断状态），则获得锁定，如果已经被检测中断（处于中断状态）则出现异常。
boolean tryLcok()：仅在调用时锁定未被另一个线程保持的情况下，才获得该锁定。
boolean tryLock(long timeout, TimeUnit unit)：如果锁定在给定等待时间内没有被另一个线程保持，且当前线程未被中断，则获得该锁定。
condition的API：
awaitUninterruptibly()：此方法为condition的方法await()的替代。可以避免在挂起的时候遇到打断状态（interrupt）而爆出异常。
awaitUntil()：在指定时间后唤醒自己。参数为long。在线程等待期间也可以被其他线程唤醒。
4.2 使用 ReentrantReadWriteLock 类
读写锁：一个是读操作相关的锁，也成为共享锁；另一个是写操作相关的锁，也叫排他锁。
读锁之间不互斥，读锁与写锁互斥，写锁与写锁互斥。
在没有线程进行写操作时，多个进行读操作的线程都可以获取读锁，而进行写入操作的Thread只有在获取写锁后才能进行写入操作。
多个线程可以同时进行读操作，但同一时刻只允许一个Thread进行写入操作。
可以通过如下代码获取读写锁：
private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
lock.readLock().lock()：可以获得读锁，并进行加锁。
lock.writeLock().lock()：就可以获得写锁，并进行加锁。