LOCK 和ReenTrantLock

JDK1.5之前的Synchronized锁是独占锁，性能不高，Lock锁借助JNI完成的高级锁实现

Lock接口

LOCK接口实现的锁比Synchronized锁更加钢钒，提供了更加灵活的操作，支持多个Condition对象
Lock接口在java.util.concurrent.locks包路径下
Lock提供的方法
lock

void lock()//获取锁，如果锁不可用时，当前的线程会进入休眠

lockInterruptibly

void lockInterruptibly() throws InterruptedException

如果当前线程未被中断，则可以获取锁
如果当前为发生中断，且锁不可用（锁被其他线程占有），当前线程会进入到休眠
tryLock

boolean tryLock()

尝试性获取锁，仅在锁空闲是才能获取锁，如果锁可用，则立即获取锁，返回true，如果锁不可用，则返回false
通常对于不是必要必须获取锁的操作可能有用
tryLock(long time, TimeUnit unit)

 boolean tryLock(long time, TimeUnit unit) throws InterruptedException

在一定时间内尝试性的获取锁，如果锁在给定的等待时间内空闲，并且当前的线程未被中断，则可以获取锁，如果锁可用，则立即获取锁，返回true，如果锁不可用，则返回false
在以下情况该线程会处于休眠状态：
• 锁有当前的线程获取
• 其他无关线程中断当前的线程，并且支持锁获取的中断
• 已超过指定的等待时间
unlock

void unlock()

释放锁，对lock()/lockInterruptibly()/trylock()/tryLock(X)等操作，加锁和释放锁都必须通过方法的显性调用来实现
newCondition

Condition newCondition()

返回绑定到此Lock实例上的新的Condition实例，Condition实例是可以进行线程间通信的

AQS

在介绍锁之前，介绍下**AQS（AbstractQueuedSynchronizer）**是J.U.U中最复杂的一个类
通过继承体系可以看出，AQS类是countDownLatch\ReentrantLock…的实现前提，公平性锁和非公平性锁、从condition…的实现的基础

AQS核心字段
AQS里面有三个核心字段

private transient volatile Node head;
private transient volatile Node tail;
private volatile int state;

其中state描述的是有多少线程获取锁，
AQS的state的值：

state = 0 表示锁是空闲状态
state > 0 表示锁被占用，state的值n表示被线程占用的次数
state < 0 表示溢出

head和tail加上CAS操作构成了一个FIFO的队列

static final class Node {
        //共享模式等待
       static final Node SHARED = new Node();
       //独占模式等待
        static final Node EXCLUSIVE = null;
        static final int CANCELLED =  1;
        static final int SIGNAL    = -1;
        static final int CONDITION = -2;
        static final int PROPAGATE = -3;

        volatile int waitStatus;
        volatile Node prev;
        volatile Node next;
        volatile Thread thread;
        Node nextWaiter;
    }

waitStatus:节点的等待状态，一个节点可以存在的状态
CANCELLED = 1;
当前的线程被取消，节点的操作因为超时后者对应的线程被interrupt,节点不应该存在此状态，一旦节点为该状态，就会从队列中提出
SIGNAL = -1;
表示当前节点的后续节点包含的线程需要执行，也就是unpark节点的继承节点互殴将要称为blocked状态的线程，一旦获取锁的线程释放锁之后，就需要唤醒当前节点的后续节点
CONDITION = -2;
当前节点在等待Condition，在Condition队列中，表明节点对应的线程不满足codition条件而被阻塞，
PROPAGATE = -3;
场景下后续的acquireShared能够得以执行
0： 当前的节点在sync队列，等待着获取锁，正常的状态，新产生的非Condition节点都是次状态
volatile Node prev：此节点的前一个节点，节点的waitStatus依赖前一个节点的状态
volatile Node next：次节点的后续节点，后一个节点是否被唤醒（unpark()）依赖于当前节点是否被释放
volatile Thread thread：当前的阶段绑定的线程
Node nextWaiter：下一个等待条件（Condition）的节点
AQS同步器的原理
AQS的原理是实现了一个同步器，同步器支持两个主要操作
获取锁：
首先判断当前的状态是否允许获取锁，如果是则直接获取锁，否则就则塞操作或者获取失败，如果是独占锁就可能会阻塞，如果是共享锁就可能失败，如果是阻塞线程，那么线程就会进入阻塞队列，当状态为允许获取锁修改状态，并且从阻塞队列里删除掉
释放锁：
这个过程就是修改状态位，如果有线程因为状态位则塞的话就会唤醒队列中的一个 或者更多线程
支持以上操作必须满足以下条件：

• 原子性的操作同步器的状态位
• 阻塞和唤醒线程
• 一个有序的队列

状态位的原子操作
使用的是一个32位的整数state来描述状态位，使用CAS操作来修改状态
阻塞和唤醒线程
借助JNI在LockSupport类中实现来操作线程的阻塞和唤醒

LockSupport.park() LockSupport.park(Object)
LockSupport.parkNanos(Object, long) LockSupport.parkNanos(long)
LockSupport.parkUntil(Object, long) LockSupport.parkUntil(long)
LockSupport.unpark(Thread)

park（）是在当前的线程中调用，会导致线程阻塞，
unpark()也是在当前线程中调用，用来唤醒线程
有序列队
在AQS采用的是CHL的FIFO队列解决线程有序等待问题
入队：
就是当前队列中的尾节点指向新节点，新节点的prev指向队列中的尾节点，然后将同步器的tail节点指向新节点。

//新创建的节点放入到同步器中 
private Node addWaiter(Node mode) {
       //新创建的节点
        Node node = new Node(Thread.currentThread(), mode);
        // Try the fast path of enq; backup to full enq on failure
       //尝试性的获取尾节点，如果失败则调用enq方法设置尾节点
        Node pred = tail;
       //判断tail节点是否为空，不为空则添加节点到对垒中
        if (pred != null) {
            node.prev = pred;
            //cas操作设置尾节点
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
        enq(node);
        return node;
    }

private Node enq(final Node node) {
       //死循环，直至节点插入到队列位置
        for (;;) {
            Node t = tail;
            //如果队列为null，则首先添加一个空节点到队列中
            if (t == null) { // Must initialize
                if (compareAndSetHead(new Node()))
                    tail = head;
            } else {
                //tail不为null，则CAS设置尾节点
                node.prev = t;
                if (compareAndSetTail(t, node)) {
                    t.next = node;
                    return t;
                }
            }
        }
 }

通过源码看出，将节点添加到队列的尾节点，使用了CAS方法compareAndSetTail
入队的过程：
出队列：遵循队列FIFO的规范
需要借助于CAS保证并发的安全性，同一时刻一个线程获取到同步状态

ReentrantLock

公平性锁和非公平性锁

非公平性：
如果一个线程因为CPU时间全部被其他的线程抢走而无法获得CPU的执行时间，这种状态称之为饥饿，而该线程被称为“饥饿致死”，非公平锁就存在“饥饿”，因为线程得不到CPU的运行时间机会。
公平性：
所有的线程均能公平性的获取到执行的机会
Java的线程饥饿原因：
1、高优先级的线程抢夺所有的低优先级的线程CPU时间
2、线程被永久阻塞在一个等待进入同步块的状态
3、线程在等待一个本身也处于永久等待完成的对象（比如调用这个对象的wait方法）
公平性锁的实现：
Lock类转换为公平锁FairLock，原理是：每一个Lock调用的线程都回去进入到队列，当解锁后，只有队列中的第一个线程被允许获取锁
ReentrantLock实现:
ReentrantLock是Java中的课重入锁的一种实现，一次只能有一个线程持有锁，也就是独占锁的概念
包含三个内内部类：Sync、NonFairSync、FairSync,公平性锁和非公平性锁通过构造函数来指定

public class ReentrantLock implements Lock, java.io.Serializable {
    //默认的非公平锁
  public ReentrantLock() {
        sync = new NonfairSync();
    }
    
    //fair决定是公平性锁和非公平性锁 true：公平锁 false：非公平锁
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }
    
    //加锁
    public void lock() {
        sync.lock();
    }
    
    //非公平性锁实现
    public boolean tryLock() {
        return sync.nonfairTryAcquire(1);
    }
    
    //释放锁
    public void unlock() {
        sync.release(1);
    }
    
    public Condition newCondition() {
        return sync.newCondition();
    }
   
   //判断有线程在等待锁
   public final boolean hasQueuedThreads() {
        return sync.hasQueuedThreads();
    }

}

使用示例
公平锁和非公平锁的不同
A、B两个线程不断的获取共享的变量，为了保证变量的并发安全，分别使用公平锁和非公平锁实现加锁操作
实现类：

public class NonFairAndFairDemo implements Runnable {
    private static Integer num = 0;
    private ReentrantLock rtl;

    public NonFairAndFairDemo(ReentrantLock rtl) {
        this.rtl = rtl;
    }

    @Override
    public void run() {
        while (true) {
            //显性加锁
            rtl.lock();
            num++;
            System.out.println(Thread.currentThread().getName()+":"+num);
            //显性释放锁
            rtl.unlock();
        }
    }
}

公平性锁的调用：

非公平锁调用：
非公平性线程执行结果：
注意：Lock锁的使用：

加锁和释放锁是显性调用 加锁和释放锁必须成对出现 多把锁的使用遵循先加锁后释放，后加锁先释放的原则

ReentrantLock的源码分析

ReentrantLock具体实现委托给内部类（Sync、FairSync、NonFairSync）
公平锁个非公平锁的父类Sync:

abstract static class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = -5179523762034025860L;
        //加锁操作，抽象方法，需要子类FairSync和NonFairSync实现
        abstract void lock();

        //非公平锁和公平锁都需要调用的方法
        final boolean nonfairTryAcquire(int acquires) {
            //获取当前的线程
            final Thread current = Thread.currentThread();
            //获取AQS中state属性值， state = 0：锁空闲， 大于0：锁占用 小于0：锁溢出
            int c = getState();
            if (c == 0) { //state== 0 表示锁空闲
                //通过CAS确保多线程并发操作的安全
                if (compareAndSetState(0, acquires)) {//加锁成功
                    //设置当前持有锁的线程
                    setExclusiveOwnerThread(current);
                    return true; //获取锁成功，返回
                }
            } 
            //和if相对应的是锁非空闲：当前线程持有锁和其他线程持有锁
            else if (current == getExclusiveOwnerThread()) {//当前线程要获取锁
                //对持有锁的次数进行变更（+1）
                int nextc = c + acquires;
                //state是int类型值，有符号的类型  最高位是符号为 1：负数  0：整数
                if (nextc < 0) // overflow //被锁次数上溢（很少出现）
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);//当前持有锁的线程变更锁保护的资源
                //当前线程是持有锁的线程，获取锁成功， 返回
                return true;
            }
            //锁非空闲，但持有锁的线程不是当前线程
            return false;
        }

        //释放
        protected final boolean tryRelease(int releases) {
            int c = getState() - releases;
            //只有持有锁的线程才能释放锁
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
            if (c == 0) {
                //锁被释放
                free = true;
                //c==0，真正释放锁，将持有锁的线程信息置为null
                setExclusiveOwnerThread(null);
            }
            //变更锁的状态
            setState(c);
            //当释放锁是 ，c==0时真正释放锁，c不等于0，只是将锁状态变更，不会真释放锁
            return free;
        }

       //释放当前线程持有锁
        protected final boolean isHeldExclusively() {
            return getExclusiveOwnerThread() == Thread.currentThread();
        }
        //获取Condition对象
        final ConditionObject newCondition() {
            return new ConditionObject();
        }

        //获取持有锁的线程
        final Thread getOwner() {
            return getState() == 0 ? null : getExclusiveOwnerThread();
        }

         //加锁次数  
         final int getHoldCount() {
            return isHeldExclusively() ? getState() : 0;
        }

        //释放加锁，通过state判断加锁
        final boolean isLocked() {
            return getState() != 0;
        }
    }

公平锁的实现：FairSync:

 static final class FairSync extends Sync {
        private static final long serialVersionUID = -3000897897090466540L;

        final void lock() {
            acquire(1);
        }

       //公平锁实现的tryAcquire
        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");
                //变更state值
                setState(nextc);
                return true;
            }
            return false;
        }
    }
 AQS类中方法：
    public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            //获取锁失败时，当前线程加入到等待队列
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }
    
//当前线程是否处于对队列第一个或者是当前队列为null
 public final boolean hasQueuedPredecessors() {
        Node t = tail; // Read fields in reverse initialization order
        Node h = head;
        Node s;
        return h != t &&
            ((s = h.next) == null || s.thread != Thread.currentThread());
    }

非公平性锁：NonFairSync:

static final class NonfairSync extends Sync {
        private static final long serialVersionUID = 7316153563782823691L;
        //lock加锁操作
        final void lock() {
            if (compareAndSetState(0, 1)) //直接通过CAS抢锁，true：抢锁成功
                setExclusiveOwnerThread(Thread.currentThread());//设置锁的持有者
            else
                acquire(1); //获取锁失败，进入到常规流程，acquire会首先调用tryAcquire
        }

        protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
        }
    }

AQS的：
 public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
 }

重入锁的实现：
1、重入锁（ReenTrantLock）的实现内部包含Sync、NonFairSync、FairSync内部类
2、重入锁实现重入计数使用AQS的state属性，state大于0表示锁被占用，等于0表示锁空闲，小于0计数太多导致溢出
3、重入锁必须持有对锁持有者的引用，一次判断是否可以重入

Condition

ReentrantLock提供了线程间通信的机制，借助于Condition对象，更具有灵活性
newCondition方法：

public Condition newCondition()

返回一个Condition实例，实例需要结合Lock锁实例一起使用
Condition接口方法：

public interface Condition {
    //使当前的线程进入休眠进行等待，类似于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;
    //唤醒因await进入休眠的一个线程，类似于notify
    void signal();
    //唤醒因await进入休眠的所有线程，类似于notifyAll
    void signalAll();
}

注意点：

Condition实例的通信方法是需要和Lock实例结合一块使用
Condition实例必须是有当前的Lock实例创建的，否则会抛出IllegalMonitorStateException
await和signal必须作用于同一个Condition实例，通信才能被接收
await和signal/signalAll使用必须进行加锁（Lock实例，显性的进行加锁释放锁）

public class ConditionDemo {
    //锁实例
   static ReentrantLock lock = new ReentrantLock();
   //Condition实例
   static Condition condition = lock.newCondition();

    static class AwaitTh extends Thread {
        @Override
        public void run() {
            lock.lock();
            long millis = System.currentTimeMillis();
            try {
                condition.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            long l = System.currentTimeMillis() - millis;
            System.out.println(Thread.currentThread().getName()+"耗时："+l);

            lock.unlock();
        }
    }


    static class SignalDemo extends Thread {
        @Override
        public void run() {
            lock.lock();
            try {
                //休眠5秒
                Thread.sleep(10000);
                System.out.println(Thread.currentThread().getName()+"发送通知");
                condition.signal();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) {
        new AwaitTh().start();
        new SignalDemo().start();
    }
 }

Condition与Object提供的wait、notify、notifyAll的区别:
相同点：
都可以进行线程间通信，Condition中的await方法相当于Object的wait方法，Condition中的signal方法相当于Object的notify方法,…
不同点：
1、Object中的通信方法是和同步锁捆绑使用（Synchronized）、Condition需要使用互斥锁、共享锁（Lock实例）
2、Condition能更加精细的控制多线程的休眠和唤醒，对于同一个锁，可以创建多个Condition，在不同的情况加使用不同的Condiion

生产者-消费者模型

生产者-消费者（producer-consumer）问题，称之为有界缓冲区问题，两个线程共享一个固定的大小的缓冲区
其中一个是生产者、生产消息存放到缓冲区、另一个是消费者，在缓冲区取出消息

具体说明：
生产者生产数据到缓存区，消费者从缓存去取数据
如果缓存区满了，则生产者线程阻塞
如果缓存区空了，消费者线程阻塞
将阻塞的线程在一定的时间进行唤醒，通过线程的通信机制来唤醒，对于生产者线程，他的唤醒是有消费者有消费时就可以通知唤醒，同样，对于消费者线程，他的唤醒是有生产者生产了数据后通知唤醒

通过Synchronized和wait、notify、notifyAll实现
生产者：

public class Producer1 implements Runnable {
    //仓库
    private LinkedList <Integer> cap;
    private Random random = new Random();

    public Producer1(LinkedList <Integer> cap) {
        this.cap = cap;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (cap) {
                try {
                    //仓库是否满
                    while (cap.size() == 3) {
                        cap.wait();
                    }

                    //生产者生产
                    int i = random.nextInt(1000);
                    System.out.println("生产者生产："+i);
                    cap.addLast(i);

                    //通知消费者,使用notify是否合适？，给定notifyAll实际上要通知到生产者、消费者
                    cap.notifyAll();

                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

消费者：

public class Consumer1 implements Runnable {
    private LinkedList <Integer> cap;

    public Consumer1(LinkedList <Integer> cap) {
        this.cap = cap;
    }

    @Override
    public void run() {
        while (true) {
            //仓库是生产者和消费者互斥使用
            synchronized (cap) {
                try {
                    //判断是否可以消费
                    while (cap.size() == 0) {
                        cap.wait();
                    }

                    //消费者消费
                    Integer value = cap.removeFirst();
                    System.out.println("消费者消费："+value);

                    //通知生产者
                    cap.notifyAll();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

通过Lock实例和Condition实现

生产者：

public class Producer2 implements Runnable {
    //仓库
    private LinkedList<Integer> cap;
    //Lock锁实例
    private ReentrantLock lock;
    //生产通知
    private Condition noFull;
    //消费通知
    private Condition noEmpty;

    private Random random = new Random();

    public Producer2(LinkedList <Integer> cap, ReentrantLock lock, Condition noFull, Condition noEmpty) {
        this.cap = cap;
        this.lock = lock;
        this.noFull = noFull;
        this.noEmpty = noEmpty;
    }

    @Override
    public void run() {
        while (true) {
            //加锁
            lock.lock();
            try {
                //判断是否可生产
                while (cap.size() == 3) {
                    noFull.await();
                }

                int value = random.nextInt(1000);
                cap.addLast(value);
                System.out.println("生产者生产："+value);

                //通知消费者消费
                noEmpty.signal();
            }catch (Exception e) {

            }  finally {
                //释放锁
                lock.unlock();
            }
        }
    }
}

消费者：

public class Consumer2  implements Runnable{
    //仓库
    private LinkedList<Integer> cap;
    //Lock锁实例
    private ReentrantLock lock;
    //生产通知
    private Condition noFull;
    //消费通知
    private Condition noEmpty;


    public Consumer2(LinkedList <Integer> cap, ReentrantLock lock, Condition noFull, Condition noEmpty) {
        this.cap = cap;
        this.lock = lock;
        this.noFull = noFull;
        this.noEmpty = noEmpty;
    }

    @Override
    public void run() {
        while (true) {
            //加锁
            lock.lock();
            try {
                //判断是否可消费
                while (cap.size() == 0) {
                    noEmpty.await();
                }

                //消费
                Integer value = cap.removeFirst();
                System.out.println("消费者消费："+value);

                //通知生产者生产
                noFull.signal();
            }catch (Exception e) {

            }  finally {
                //释放锁
                lock.unlock();
            }
        }
    }
}

课后作业：三个生产者、三个消费者、仓库容量为3的生产者、消费者代码实现

ConcurrentHashMap

分段锁？？？如何实现