java并发包中锁
6.1LockSupport工具类
该类的主要作用就是挂起和唤醒线程，该工具类是创建锁和其他工具类的基础。LockSupport类与每个使用他的线程都关联一个许可证，在默认情况下调用LockSupport类的方法的线程是不持有许可证的。
1、void park()
如果调用park方法的线程已经那都了LockSupport关联的许可证的话，那LockSupport.park()会立刻返回，否则就会阻塞挂起。
package com.nxz.blog.otherTest; import java.util.concurrent.locks.LockSupport; public class TestThread004 { /** * LockSupport park * @param args */ public static void main(String[] args) { System.out.println("main-start"); // LockSupport的park默认是不持有许可证的，也就是说，调用park方法后，当前线程会阻塞 LockSupport.park(); System.out.println("main-end"); } }
上边运行结果：如下图，main线程会阻塞在LockSupport.park()代码处，不会输出main-end。
2、void unpark(Thread thread)方法
如果参数thread没有持有LockSupport许可，调用该方法后，会使thread持有许可证，也就是说会使调用park方法而阻塞的线程返回。（线程intercept中断之后，park方法也会返回，停止阻塞）
package com.nxz.blog.otherTest; import java.util.concurrent.locks.LockSupport; public class TestThread004 { /** * LockSupport park * @param args */ public static void main(String[] args) { System.out.println("main-start"); // 使当前线程（main线程）获取许可 LockSupport.unpark(Thread.currentThread()); // 因为上边已经获取许可了，所以，下边这个park方法并不会阻塞线程 LockSupport.park(); System.out.println("main-end"); } }
执行结果：
main-start
main-end
另外一个例子：
package com.nxz.blog.otherTest; import java.util.concurrent.locks.LockSupport; public class TestThread004 { /** * LockSupport park * * @param args */ public static void main(String[] args) throws InterruptedException { Thread t = new Thread(new Runnable() { @Override public void run() { System.out.println("runnable-start"); LockSupport.park(); System.out.println("runnable-end"); } }); t.start(); // 目的是使t线程先执行，让t线程调用park方法后阻塞 Thread.sleep(1000); System.out.println("main"); // 使t线程获取LockSupport许可，获取许可后，t线程就可以继续向下执行了 LockSupport.unpark(t); System.out.println("main-end"); } }
执行结果：
runnable-start main main-end runnable-end
3、void park(long nanos)
该方法和park方法类似，只不过是在指定时间后自动返回
4、void park(Object blocker)
一般使用的是这个方法而不是无参的park方法，原因是，这个个方法输出日志时会输出阻塞的类的信息（而park方法不会输出）。
6.2抽象同步类AQS
AbstractQueuedSynchronize抽象同步队列简称AQS，是实现同步器的基础组件，并发包中锁的实现，底层都是通过AQS实现的。
1、基本属相
// 同步器是一个双向的FIFO队列 有头结点和尾节点，节点类型Node为AQS的内部类 private transient volatile Node head; private transient volatile Node tail; // 该字段是实现锁和同步器的关键，在不同的实现类中有不同的含义，例如在ReentrantLock中代表当前线程获取可重入锁的次数，ReentrantReadWriteLock中，高16位表示读状态，也就是获取读锁的次数，低16位掉表写状态，也及时写锁的次数，Semaphore中代表限号量等等 private volatile int state;
static final class Node { // 用来标记该线程是获取共享资源时被阻塞后挂起放入AQS队列的 static final Node SHARED = new Node(); // 用来标记该线程是获取独占资源师被阻塞后防区AQS队列的 static final Node EXCLUSIVE = null; // waitstatus状态之一， 表示线程被取消了 static final int CANCELLED = 1; //waitstatus状态之一，表名线程需要唤醒 static final int SIGNAL = -1; // 线程在条件队列里边等待 static final int CONDITION = -2; // 释放共享资源师需要通知其他节点 static final int PROPAGATE = -3; // 记录当前线程的等待状态，有以上3中状态 volatile int waitStatus; // 记录当前节点的前驱节点 volatile Node prev; // 记录当前节点的后继节点 volatile Node next; // 记录当前线程 volatile Thread thread; // 下一个等待条件变量condition的节点 Node nextWaiter;
public class ConditionObject implements Condition, java.io.Serializable { // 该类用来结合所实现线程同步的，每一个ContditionObject是一个条件变量，每一个条件变量对应一个条件对列，每一个条件队列都是一个单项链表，用来存放调用await方法后阻塞的线程 // 条件队列的第一个节点 private transient Node firstWaiter; // 条件队列的最后一个节点 private transient Node lastWaiter; }
6.3ReentrantLock可重入的独占锁
1、结构图：
可以看出ReentrantLock最终还是通过AQS实现的，并根据参数判断锁是公平的还是非公平的
// 默认构造是创建一个非公平锁 public ReentrantLock() { sync = new NonfairSync(); } // 有参构造，fair：true则创建一个公平锁，false：创建非公平锁 public ReentrantLock(boolean fair) { sync = fair ? new FairSync() : new NonfairSync(); }
2、void lock()
public void lock() { sync.lock(); } // Sync类中为抽象方法，具体实现，需要看公平锁和非公平锁中的实现方法 abstract void lock(); // 非公平锁类 static final class NonfairSync extends Sync { // lock实现方法 final void lock() {
// 通过CAS操作state变量，state默认为0，表名没有被线程获取，设置为1成功后，代表该线程获取锁成功，此时state为1，并设置exclusiveThread为当前线程 if (compareAndSetState(0, 1)) setExclusiveOwnerThread(Thread.currentThread()); else // 调用AQS的acquire方法，AQS内部会条用tryAcquire方法 acquire(1); } protected final boolean tryAcquire(int acquires) { return nonfairTryAcquire(acquires); } } // 公平锁 static final class FairSync extends Sync { final void lock() { acquire(1); } protected final boolean tryAcquire(int acquires) { final Thread current = Thread.currentThread(); int c = getState(); if (c == 0) { if (!hasQueuedPredecessors() && compareAndSetState(0, acquires)) { setExclusiveOwnerThread(current); return true; } } else if (current == getExclusiveOwnerThread()) { int nextc = c + acquires; if (nextc < 0) throw new Error("Maximum lock count exceeded"); setState(nextc); return true; } return false; } }
3、lockInterruptibly()方法，可中断的lock方法
和lock类似，区别就是能够对中断进行相应（而lock方法对于中断操作是忽视的）
4、trylock()方法
如果当前锁没有被其他线程持有，则调用该方法时会立即返回，如果被其他线程持有，则该方法也会立即返回false。（该方法不会阻塞，lock方法会阻塞，即会进入阻塞队列中）。
public boolean tryLock() { return sync.nonfairTryAcquire(1); } final boolean nonfairTryAcquire(int acquires) { final Thread current = Thread.currentThread(); int c = getState(); // 如果state为0，即该锁没有被其他线程持有，则该线程通过CAS操作后，持有锁，会理解返回true if (c == 0) { if (compareAndSetState(0, acquires)) { setExclusiveOwnerThread(current); return true; } } // 如果持有锁的线程是当前线程，则state累计额acquires后，返回true else if (current == getExclusiveOwnerThread()) { int nextc = c + acquires; if (nextc < 0) // overflow throw new Error("Maximum lock count exceeded"); setState(nextc); return true; } // 返回false，在锁被其他线程持有时会立即返回false return false; }
5、释放锁unlock()
如果所被当前线程持有，则state赋为0，即释放锁，如果所被当前线程多次持有，则state只是减1，并不会释放锁。如果当前线程没有持有锁，则跑异常。
6.4ReentrantReadWriteLock读写锁
采用读写分离的策略，允许多个线程可以同时获取锁。
1、结构:有两个锁，WriteLock和ReadLock
public class ReentrantReadWriteLock implements ReadWriteLock, java.io.Serializable { // 读锁 private final ReentrantReadWriteLock.ReadLock readerLock; // 写锁 独占锁 private final ReentrantReadWriteLock.WriteLock writerLock; // 同步时 继承自AQS类 final Sync sync; public ReentrantReadWriteLock() { this(false); } public ReentrantReadWriteLock(boolean fair) { sync = fair ? new FairSync() : new NonfairSync(); readerLock = new ReadLock(this); writerLock = new WriteLock(this); } public ReentrantReadWriteLock.WriteLock writeLock() { return writerLock; } public ReentrantReadWriteLock.ReadLock readLock() { return readerLock; } }
ReentrantReadWriteLock和ReentrantLock类似，只不过内部分为写锁和读锁，对于aqs中state变量的控制，在ReentrantLock中，0表示未被线程获取，而在读写锁中，将state分成两份，高16位负责记录读锁和低16位负责写锁。
6.5jdk8中新增的StampedLock锁
该锁是jdk8中新增的，提供了3中模式的读写控制，当调用获取锁的函数时，会返回一个long类型的变量，也就是戳记（stamp），代表锁的状态。当调用释放锁和转换锁的时候，需要将该stamp作为参数传入。
写锁writeLock：是一个独占锁，同一时间只能有一个线程可以获取锁（并且是不可冲入锁）
悲观读锁readLock：是一个共享锁，在没有线程获取的情况下多个线程可以获取到锁，但是只要有线程获取到写锁，则获取读锁的线程都会阻塞（同时该锁也是不可冲入锁）
乐观读锁tryOptimisticRead
使用案例：
/** * jdk8中stampedLock中提供的例子 * 管理二维点的类 */ class Point { private double x, y; private final StampedLock sl = new StampedLock(); /** * 独占的方法 */ void move(double deltaX, double deltaY) { // an exclusively locked method // 获取写锁 long stamp = sl.writeLock(); // x y坐标调整 try { x += deltaX; y += deltaY; } finally { // 释放写锁 sl.unlockWrite(stamp); } } /** * 共享方法，使用了乐观的共享锁 */ double distanceFromOrigin() { // A read-only method // 获取乐观的读锁 long stamp = sl.tryOptimisticRead(); // 获取point对象坐标的拷贝 double currentX = x, currentY = y; // 验证stamp（也就是之前获取的锁是否仍然可用），如果可用的话，则直接进行运算，不可用的话，则获取一个悲观的读锁readlock if (!sl.validate(stamp)) { // 在stamp不可用情况下，重新获取一个悲观读锁 stamp = sl.readLock(); try { // 重新设置xy的拷贝 currentX = x; currentY = y; } finally { // 释放悲观读锁 sl.unlockRead(stamp); } } // 返回两点之间的距离 return Math.sqrt(currentX * currentX + currentY * currentY); } // 更原点 void moveIfAtOrigin(double newX, double newY) { // upgrade // Could instead start with optimistic, not read mode long stamp = sl.readLock(); try { // 如果x=y=0是，修改坐标 while (x == 0.0 && y == 0.0) { // 将之前获取到的读锁转换为一个写锁 long ws = sl.tryConvertToWriteLock(stamp); //ws不等于0，则代表锁转换成功 if (ws != 0L) { stamp = ws; x = newX; y = newY; break; } else { // 转换失败后，释放读锁，重新获取一个写锁，重复while循环 sl.unlockRead(stamp); stamp = sl.writeLock(); } } } finally { // 释放锁 sl.unlock(stamp); } } }
stampedlock和ReentrantReadWriteLock类似，只不过前者是不可重入锁，但是前者在提供的乐观读锁在多线程环境下提供了更好的性能，这是因为乐观读锁不需要进行CAS操作设置锁的状态，只是简单的验证了一下锁的stamp是否可用。