Java中还有一套并发工具包，位于包java.util.concurrent下，里面包括很多易用
且很多高性能的并发开发工具。
一、原子变量和CAS
为什么需要原子变量，因为对于例如count++这种操作，使用
synchronized成本太高了。Java并发包的基本原子变量有：
AtomicBoolean、AtomicInteger、AtomitLong和AtomicReference(原子引用类型)
一）AtomicInteger
1.用法
构造方法：
public AtomicInteger(int initialValue) public AtomicInteger() //初始值为0
get/set方法：
public final int get() public final void set(int newValue)
之所以称为原子变量，是因为它们包含一些以原子方式实现组合操作的方法。部分方法如下：
//以原子方式获取旧值并设置新值 public final int getAndSet(int newValue) //以原子方式获取旧值并给当前值加一 public final int getAndIncrement() //以原子方式获取旧值并给当前值减一 public final int getAndDecrement() //以原子方式获取旧值并给当前值加delta public final int getAndAdd(int delta) //以原子方式给当前值加一并获取新值 public final int incrementAndGet() //以原子方式给当前值减一并获取新值 public final int decrementAndGet() //以原子方式给当前值加delta并获取新值 public final int addAndGet(int delta)
以上方法都依赖于方法：
/** * @param expect 如果当前值等于expect,则更新当前值为update * @param update 更新后的值 * @return 更新成功返回true,否则返回false * */ public final boolean compareAndSet(int expect, int update)
compareAndSet是一个非常重要的方法，比较并设置，我们以后简称为CAS。
应用示例：
public class AtomicIntegerDemo { private static AtomicInteger counter = new AtomicInteger(0); static class Vistor extends Thread { @Override public void run() { for (int i = 0; i < 1000; i++) { counter.incrementAndGet(); } } } public static void main(String[] args) throws InterruptedException { int num = 1000; Thread[] threads = new Thread[num]; for (int i = 0; i < num; i++) { threads[i] = new Vistor(); threads[i].start(); threads[i].join(); } System.out.println(counter.get()); //1000000 } }
2.基本原理和思维
主要内部成员：
private volatile int value; //volatile可保证内存可见性
public final int incrementAndGet() { for(;;) { //获取当前值 int current = get(); //计算更新值 int next = current + 1; //如果更新没有成功，说明value被别的线程改了，则再去取最新值 //并尝试更新直到成功为止 if(compareAndSet(current, next)) return next; } }
原子变量的更新逻辑是非阻塞式，更新冲突的时候，它就重试，
不会阻塞，不会有上下文切换开销。对于大部分比较简单的操作，
这种方式性能都远高于使用阻塞的方式。
接下来是compareAndSet实现源代码：
public final boolean compareAndSet(int expect, int update) { return unsafe.compareAndSwapInt(this, valueOffset, expect, update); }
其中usafe是sun.misc.Unsafe类型，定义为：
private static final Unsafe unsafe = Unsafe.getUnsafe();
一般应用程序不应该直接使用。原理上，一般的计算机系统都在硬件层次上直接支持CAS指令，
Java的实现都会利用这些特殊的指令。
3.实现锁
基于CAS，除了可以实现乐观非阻塞外，还可以实现悲观阻塞式算法，比如锁。
实际上，Java并发包的所有阻塞式工具、容器、算法都是基于CAS的（不过，也需要一些别的支持）。
我们自己来实现一个简单的锁：
/** * 一般而言这种阻塞方式过于消耗CPU，实际开发中应该使用并发包中的类 * 这里只是一个演示 */ public class MyLock { //status表示锁的状态，0表示未锁定，1表示锁定 private AtomicInteger status = new AtomicInteger(0); public void lock() { //更新成功后才退出 while (!status.compareAndSet(0, 1)){ Thread.yield(); } } public void unlock() { status.compareAndSet(1, 0); } }
4.ABA问题
假设当前值为A，如果另一个线程先将A修改成B，再修改A，
当前线程的CAS操作无法分辨当前值发生变化。解决办法
是使用AtomicStampedReference，在修改值的同时附件一个时间戳，
只有值和时间戳都相同才能进行修改，其CAS声明方法为：
public boolean compareAndSet(V expectedReference, V newReference, int expectedStamp, int newStamp)
Pair pair = new Pair(100, 200); int stamp = 1; AtomicStampedReference<Pair> pairRef = new AtomicStampedReference<Pair>(pair, stamp); int newStamp = 2; pairRef.compareAndSet(pair, new Pair(200, 200), stamp, newStamp);
二、显式锁
Java并发包中的显式锁接口和类位于包java.util.concurrent.locks下，主要接口和类如下：
1）锁接口Lock，主要实现类是ReentrantLock;
2）读写锁和接口：ReadWriteLock,主要实现类是ReentrantReadWriteLock；
一）接口Lock
public interface Lock { void lock(); void lockInterruptibly() throws InterruptedException; boolean tryLock(); boolean tryLock(long time, TimeUnit unit) throws InterruptedException; void unlock(); Condition newCondition(); }
1）lock()/unlock():获取锁和释放锁，lock会阻塞直到成功。
2）lockInterruptibly():与lock()不同的是，它可以响应中断，如果被其他线程中断了，则抛出InterruptedException.
3）tryLock()：只是尝试获取锁，立即返回，不阻塞，如果成功，返回true，否则返回false。
4）tryLock(long time, TimeUnit unit):在限定时间内等待，如果成功返回true，否则阻塞，在等待同时响应中断，超出时间没有获得锁，抛出false。
5）newCondition():
二）可重入锁ReentrantLock
1.基本用法
该类方法lock()和unlock()实现了synchronized一样的语义，但：
1）可重入，一个线程在持有锁的情况下，可以继续获得该锁；
2）可以解决竞态条件问题；
3）可以保证内存可见性；
ReentrantLock有两个构造方法：
//默认为不公平锁 public ReentrantLock() //设定true为公平锁 public ReentrantLock(boolean fair)
所谓公平是指，等待时间最长的线程优先获得锁。保证公平会英雄性能，一般也不需要，所以默认不保证。
public class Counter { private final Lock lock = new ReentrantLock(); private volatile int count; public void incr() { lock.lock(); try { count ++; //注意一定不要忘记释放锁 } finally { lock.unlock(); } } public int getCount() { return count; } }
2.使用tryLock()避免死锁
在持有一个锁同时获取另一个锁而获取不到的时候，可以释放
已持有的锁，给其他线程获取锁的机会，然后重试获取所有锁。
账户之间转账的例子：
public class Account { private Lock lock = new ReentrantLock(); private volatile double money; public Account(double money) { this.money = money; } public void add(double money) { lock.lock(); try { this.money += money; } finally { lock.unlock(); } } public void reduce(double money) { lock.lock(); try { this.money -= money; } finally { lock.unlock(); } } public double getMoney() {return this.money;} void lock() { lock.lock(); } void unlock() { lock.unlock(); } boolean tryLock() { return lock.tryLock(); } }
public class AccountManager { public static class NoEnoughMoneyException extends Exception {} //该方法问题：如果两个账户同时给对方转账，都先获得了第一个锁，则会发生死锁 public static void transfer(Account from, Account to, double money) throws NoEnoughMoneyException { from.lock(); try { to.lock(); try { if (from.getMoney() >= money) { from.reduce(money); to.add(money); } else { System.out.println("The from account money is " + from.getMoney()); System.out.println("The money is " + money); throw new NoEnoughMoneyException(); } } finally { to.unlock(); } } finally { from.unlock(); } } //避免死锁的方法 public static boolean tryTransfer(Account from, Account to, double money) throws NoEnoughMoneyException { if (from.tryLock()) { try { if (to.tryLock()) { try { if (from.getMoney() >= money) { from.reduce(money); to.add(money); } else { throw new NoEnoughMoneyException(); } return true; } finally { to.unlock(); } } } finally { from.unlock(); } } return false; } //模拟账户转账的死锁过程 public static void simulateDeadLock() throws InterruptedException { final int accountNum = 10; final Account[] accounts = new Account[accountNum]; final Random random = new Random(); for (int i = 0; i < accountNum; i++) { accounts[i] = new Account(random.nextInt(1000000)); System.out.println("account[" + i + "]" + accounts[i].getMoney()); } int threadNum = 100; Thread[] threads = new Thread[threadNum]; for (int i = 0; i < threadNum; i++) { threads[i] = new Thread() { @Override public void run() { int loopNum = 100; for (int k = 0; k < loopNum; k++) { int i = random.nextInt(accountNum); int j = random.nextInt(accountNum); int money = random.nextInt(10); if (i != j) { try { System.out.println( "Thread account[" + i + "]"+ accounts[i].getMoney()); //会发生死锁 transfer(accounts[i], accounts[j], money); } catch (Exception e) { e.printStackTrace(); } } } } }; threads[i].start(); } } public static void main(String[] args) { try { simulateDeadLock(); } catch (InterruptedException e) { e.printStackTrace(); } } }
3.ReentrantLock的实现原理
在最底层，该类依赖于CAS方法，另外，它依赖于LockSupport的一些方法。
1）LockSupport
LockSupport类的基本方法：
//使当前线程放弃CPU，进入等待（WAITING）状态 public static void park() //使指定线程恢复可运行状态 public static void unpark(Thread thread)
Thread t = new Thread(){ @Override public void run() { LockSupport.park(); System.out.println("exit"); } }; t.start(); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } LockSupport.unpark(t);
park不同于Thread.yield(),yield只是告诉操作系统可以先让其他线程运行，
但自己仍然是可运行状态。另外，park是响应中断的，当有中断发生时，park
会返回，线程的中断状态会被设置。另外，还需要说明的，park可能会无缘无故
地返回，程序应该重新检查park等待条件是否满足。park的两个变体：
//可指定最长等待时间，参数是相对于当前时间的纳秒数 public static void parkNanos(long nanos) //指定最长等待到什么时候，参数是绝对时间 public static void parkUntil(long deadline)
当等待超时，它们也会返回。
也可以指定一个对象，表示是由于该对象而进行等待，以便调试：
public static void park(Object blocker)
返回一个线程的blocker对象：
public static Object getBlocker(Thread t)
2）AQS
Java提供了一个抽象类AbstractQueuedSynchronizer简称AQS，用于各种锁的代码复用。
AQS封装了一个状态，给子类提供查询和设置状态的方法：
private volatile int state; protected final int getState() protected final void setState(int newState) protected final boolean compareAndSetState(int expect, int update)
用于实现锁时，AQS可以保存锁的当前持有线程，提供了方法进行查询和设置：
private transient Thread exclusiveOwnerThread(); protected final void setExclusiveOwnerThread(Thread t); protected final Thread getExclusiveOwnerThread();
下面，我们以ReentrantLock的使用为例简要介绍AQS的原理：
ReentrantLock内部使用AQS，有三个内部类：
abstract static class Sync extends AbstractQueuedSynchronizer //fair为false使用该类 static final class NonfairSync extends Sync //fair为true时使用该类 static final class FairSync extends Sync
ReentrantLock内部有一个Sync成员：
private final Sync sync;
在构造方法中被赋值：
public ReentrantLock() { sync = new NonfairSync(); }
lock/unlock方法的实现：
public void lock() { sync.lock(); }
sync默认类型是NonfairSync,NonfairSync的lock代码为：
final void lock() { if(compareAndSetState(0, 1)) setExclusiveOwnerThread(Thread.currentThread()); else acquire(1); }
ReentrantLock使用state表示是否被锁和持有数量，如果当前未被锁定，则立即获得锁，
否则调用acquire(1)获得锁。acquire()是AQS中的方法，代码为：
public final void acquire(int arg) { if(!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) selfInterrupt(); }
它调用tryAcquire()获取锁，tryAcquire必须被子类重写。NofairSync的实现为：
protected final boolean tryAcquire(int acquires) { return nonfairTryAcquire(acquires); }
final boolean nonfairTryAcquire(int acquires) { final Thread current = Thread.currentThread(); int c = getState(); //如果未被锁定，则进行锁定 if(c == 0) { if(compareAndSetState(0, acquires)) { setExclusiveOwnerThread(current); return true; } } //如果已经锁定，增加锁定次数，这里state存放了锁定次数 else if(current == getExclusiveOwnerThread()) { int nextc = c + acquires; if(nextc < 0) // overflow throw new Error("Maximum lock count exceeded"); setState(nextc); return true; } return false; }
如果tryAcquire()返回false,则AQS会调用：
//addWaiter()会新建一个节点Node，代表当前线程，然后加入内部等待队列 //放入等待队列后，调用acquireQueued尝试获得锁 acquireQueued(addWaiter(Node.EXCLUSIVE), arg)
final boolean acquireQueued(final Node node, int arg) { boolean failed = true; try { boolean interrupted = false; for(;;) { //首先检查当前节点是不是第一个等待节点 //如果是且能得到锁则将当前节点从等待队列中移除并返回 final Node p = node.predecessor(); if(p == head && tryAcquire(arg)) { setHead(node); p.next = null; // help GC failed = false; return interrupted; } //否则最终调用LockSupport.park放弃CPU，进入等待， //被唤醒后检查是否中断，记录中断标志 if(shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt()) interrupted = true; } } finally { if(failed) cancelAcquire(node); } }
private static void selfInterrupt() { Thread.currentThread().interrupt(); }
总结lock方法的基本过程：能获得锁就立即获得，否则加入等待队列，被唤醒后检查
自己是否是第一个等待的线程，如果是且能获得锁，则返回，否则继续等待。这个过程
如果发生了中断，lock会记录中断标志位，但不会提前返回或抛出异常。
ReentrantLock的unlock代码为：
public void unlock() { sync.release(1); }
public final boolean release(int arg) { //tryRelease会修改状态释放锁 if(tryRelease(arg)) { Node h = head; if(h != null && h.waitStatus != 0) //会调用LockSupport.unpark将第一个等待的线程唤醒 unparkSuccessor(h); return true; } return false; }
4.对比ReentrantLock和synchronized
相比synchronized，ReentrantLock,支持以非阻塞方式获取锁，
可以响应中断，可以限时，更为灵活。不过synchronized使用更简单
性能通常更好，总之能用synchronized就不要用ReentrantLock。
三、显式条件
1.用法
锁用于解决竞态条件问题，条件是线程间的协作机制。显式锁与synchronized相对应，
而显式条件与wait/notify相对应。显式锁与显式条件配合使用。Lock接口中定义的创建
显示条件的方法：
Condition newCondition();
Condition接口：
public interface Condition { //对应于Object的wait void await() throws InterruptedException; //不响应中断的等待，该方法不会由于中断结束，但当它返回时 //如果等待过程中发生中断，中断标志会被设置 void awaitUninterruptibly(); //等待相对时间，单位纳秒 long awaitNanos(long nanosTimeout) throws InterruptedException; //等待相对时间 boolean await(long time, TimeUnit unit) throws InterruptedException; //等待绝对时间 boolean awaitUntil(Date deadline) throws InterruptedException; //对应于notify void signal(); void signalAll(); }
与Object的wait方法一样，调用await方法前先要索取锁，如果没有锁会抛出异常。
当await在进入等待队列后，会释放锁，释放CPU，当其他线程唤醒它后，或等待
超时后，或发生中断异常后，它都需要重新获取锁，获取锁后，才会从await方法中退出。
另外，与Object的wait方法一样，await返回后就不一定代表等待的条件就满足了，
通常要将await的调用放到一个循环内，只有条件满足后才退出。示例：
public class WaitThread extends Thread{ private volatile boolean fire = false; private Lock lock = new ReentrantLock(); private Condition condition = lock.newCondition(); @Override public void run() { try { lock.lock(); try { while (!fire){ condition.await(); } } finally { lock.unlock(); } System.out.println("fired"); } catch (Exception e) { e.printStackTrace(); } } public void fire() { lock.lock(); try { this.fire = true; condition.signal(); } finally { lock.unlock(); } } public static void main(String[] args) throws InterruptedException { WaitThread waitThread = new WaitThread(); waitThread.start(); Thread.sleep(1000); System.out.println("fire"); waitThread.fire(); } }
2.生产者/消费者模式
在使用wait/notify实现生产者/消费者的时候有一个局限就是只能有一个条件队列，
而使用显式锁和条件不存在这个问题，例如：
public class MyBlockingQueue<E> { private Queue<E> queue = null; private int limit; private Lock lock = new ReentrantLock(); private Condition notFull = lock.newCondition(); private Condition notEmpty = lock.newCondition(); public MyBlockingQueue(int limit) { this.limit = limit; queue = new ArrayDeque<E>(limit); } public void put(E e) throws InterruptedException { lock.lockInterruptibly(); try { while (queue.size() == limit) { notFull.await(); } queue.add(e); notEmpty.signal(); } finally { lock.unlock(); } } public E take() throws InterruptedException { lock.lockInterruptibly(); try { while (queue.isEmpty()) { notEmpty.await(); } E e = queue.poll(); notFull.signal(); return e; } finally { lock.unlock(); } } }
3.实现原理
ReentrantLock的newCondition():
public Condition newCondition() { return sync.newCondition(); }
sync的newCondition方法：
final ConditionObject newCondition() { return new ConditionObject(); }
ConditionObject是AQS的一个内部类，其内部有一个队列，
表示条件等待队列，其成员声明：
//条件队列的头节点 private transient Node firstWaiter; //条件队列的尾节点 private transient Node lastWaiter;
public final void await() throws InterruptedException { //如果等待前中断标志位已经被设置，直接抛异常 if (Thread.interrupted()) throw new InterruptedException(); //1.为当前进程创建节点，加入条件等待队列 Node node = addConditionWaiter(); //2.释放持有的锁 int savedState = fullyRelease(node); int interruptMode = 0; //3.放弃CPU进行等待，直到被中断或isOnSyncQueue变为true //isOnSyncQueue,表示该节点被其他线程从条件等待队列 //移到了外部锁等待队列，等待的条件已经满足 while (!isOnSyncQueue(node)) { LockSupport.park(this); if ((interruptMode = checkInterruptWhileWaiting(node)) != 0) break; } //重新获取锁 if (acquireQueued(node, savedState) && interruptMode != THROW_IE) interruptMode = REINTERRUPT; if (node.nextWaiter != null) // clean up if cancelled unlinkCancelledWaiters(); if (interruptMode != 0) reportInterruptAfterWait(interruptMode); }