//针对上面的伪代码实现
// 撤销流程的伪代码，在全局检查点执行该操作
if mark word 存储的不是可偏向状态:
    return;     // 如果不是偏向锁，那么没有撤销偏向的必要
else:
    if Thread ID 指向的线程不存活:
        if 允许重偏向:
            退回可偏向但未偏向的状态   // Thread ID为0
        else:
            偏向撤销，变为无锁状态
    else:
        if Thread ID 指向的线程，仍然拥有锁:
            升级为轻量级锁，将mark word复制到线程栈中，然后stack pointer指向最老的相关锁记录
        else:
            if 允许重偏向:
                退回可偏向但未偏向的状态   // Thread ID为0
            else:
                偏向撤销，变为无锁状态

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.acc = System.getSecurityManager() == null ?
                null :
                AccessController.getContext();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

//无参构造方法
//无参的构造函数得到的是一个空数组
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

public ArrayList(int initialCapacity) {
    if (initialCapacity > 0) {
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    }
}

public ArrayList(Collection<? extends E> c) {
    elementData = c.toArray();
    if ((size = elementData.length) != 0) {
		// c.toArray might (incorrectly) not return Object[]
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    } else {
        // replace with empty array.
        this.elementData = EMPTY_ELEMENTDATA;
    }
}

/**
 * @param src      源数组
 * @param srcPos   源数组中的起始位置
 * @param dest     目标数组
 * @param destPos  指定目标数据中的起始位置
 * @param length   要复制的数组元素的数量.
 */
public static native void arraycopy(Object src,  int  srcPos,
                                        Object dest, int destPos,
                                        int length);

/**
 * @param original 	要复制的数组
 * @param newLength 要返回的副本的长度
 * @param newType 	要返回的副本的类型
 */
public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
        @SuppressWarnings("unchecked")
        T[] copy = ((Object)newType == (Object)Object[].class)
            ? (T[]) new Object[newLength]
            : (T[]) Array.newInstance(newType.getComponentType(), newLength);
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }

//执行顺序1.
//size默认值是0
public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}

//2.其实是执行3和4的方法
private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

//3.
/**
  * 这个方法是计算list的容量的:
  *    上面add方法调用的时候会传入(size+1)到这个计算的方法中
  *    如果当前的数组是空数组,那么就比较(size+1)与默认的容量(默认是10),取较大的值返回.
  *    如果不是空数组,那么直接返回(size+1)
  */
private static int calculateCapacity(Object[] elementData, int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        //默认容量DEFAULT_CAPACITY是10
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return minCapacity;
}

//4.
/**
  * 因为是add操作,对列表结构有改动,需要modCount++
  * 如果传入的(size+1)值大于当前数组的长度的时候,才对此数组进行扩容的操作
  */
private void ensureExplicitCapacity(int minCapacity) {
    modCount++;
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

//5.如果是超过当前数组长度才需要进行数组扩容的操作
/**
 * 如果新数组大小还是小于传入的容量的话,那就直接取传入的容量作为新数组的长度
 * 如果新数组的长度要比最大定义的数组长的话
 *      (最大的数组长度是Integer.MAX_VALUE-8)
 *      那么就直接使用Integer.MAX_VALUE作为数组的长度.
 * 然后就将数组的元素拷贝到一个新的数组中
 */
private void grow(int minCapacity) {
    int oldCapacity = elementData.length;
    //右移1位，此处得到新容量是旧容量的1.5倍
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // minCapacity is usually close to size, so this is a win:
    elementData = Arrays.copyOf(elementData, newCapacity);
}

//插入到index的下标的位置,然后返回旧的值
public E set(int index, E element) {
    //判断传入的下标是否越界
    rangeCheck(index);

    E oldValue = elementData(index);
    elementData[index] = element;
    return oldValue;
}

private void rangeCheck(int index) {
    if (index >= size)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

public E get(int index) {
    //判断传入的下标是否越界
    rangeCheck(index);
    return elementData(index);
}

public E remove(int index) {
    //判断传入的下标是否越界
    rangeCheck(index);
	//删除操作修改了列表结构
    modCount++;
    E oldValue = elementData(index);
	//需要进行移动的元素个数
    int numMoved = size - index - 1;
    if (numMoved > 0)
        //移动数组的元素
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    //更新列表的元素个数,清除最后一个元素,让GC回收
    elementData[--size] = null; // clear to let GC do its work

    return oldValue;
}

public boolean remove(Object o) {
    //移除null值元素
    if (o == null) {
        for (int index = 0; index < size; index++)
            if (elementData[index] == null) {
                fastRemove(index);
                return true;
            }
    } else {
        //for循环遍历列表,根据对象的equals方法来移除对应元素
        for (int index = 0; index < size; index++)
            if (o.equals(elementData[index])) {
                fastRemove(index);
                return true;
            }
    }
    return false;
}

//此方法是移除列表中的元素,根据下标志移除
private void fastRemove(int index) {
    modCount++;
    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    elementData[--size] = null; // clear to let GC do its work
}

public boolean removeAll(Collection<?> c) {
    //如果参数为null,那么抛出异常
    Objects.requireNonNull(c);
    return batchRemove(c, false);
}

private boolean batchRemove(Collection<?> c, boolean complement) {
    final Object[] elementData = this.elementData;
    int r = 0, w = 0;
    boolean modified = false;
    try {
        //注意此处的complement是false
        //所以就是将elementData中不存在c中的元素留下
        for (; r < size; r++)
            if (c.contains(elementData[r]) == complement)
                elementData[w++] = elementData[r];
    } finally {
        //这里的判断的原因是因为 contains 方法可能会抛出异常
        //如果抛出异常的情况下,就需要对 elementData 进行处理
        if (r != size) {
            System.arraycopy(elementData, r,
                             elementData, w,
                             size - r);
            w += size - r;
        }
        //这里很简单,清除元素,修改 modCount 的值,然后返回true
        if (w != size) {
            for (int i = w; i < size; i++)
                elementData[i] = null;
            modCount += size - w;
            size = w;
            modified = true;
        }
    }
    return modified;
}

public Iterator<E> iterator() {
    return new Itr();
}

//是否还有下一个可遍历的元素
public boolean hasNext() {
    return cursor != size;
}

public E next() {
    checkForComodification();
    int i = cursor;
    //这里都是判断下标是否越界
    if (i >= size)
        throw new NoSuchElementException();
    Object[] elementData = ArrayList.this.elementData;
    if (i >= elementData.length)
        throw new ConcurrentModificationException();
    //游标+1
    cursor = i + 1;
    return (E) elementData[lastRet = i];
}
//在获取元素之前，需要先判断列表结构是否被修改过
final void checkForComodification() {
    if (modCount != expectedModCount)
        throw new ConcurrentModificationException();
}

public void remove() {
    //这个地方就是为什么需要先执行 next 方法后才能调用 remove 方法的原因
    if (lastRet < 0)
        throw new IllegalStateException();
    //在移除元素之前，需要先判断列表结构是否被修改过
    checkForComodification();

    try {
        //调用arrayList的remove方法
        ArrayList.this.remove(lastRet);
        //重置一下游标,因为 next 操作里面将游标+1了
        cursor = lastRet;
        lastRet = -1;
        //更新结构修改次数，上面调用remove方法导致modCount增加了
        expectedModCount = modCount;
    } catch (IndexOutOfBoundsException ex) {
        throw new ConcurrentModificationException();
    }
}

/**
  * List的遍历方式
  */
public void cycleList() {
    Integer[] ints = {1,2,3,4,5,6,7,8,9};
    // Arrays.asList(ints) 将数组转成List
    List<Integer> lists = Arrays.asList(ints);
    /**
      * 1.for循环遍历
      *
      * foreach循环(增强for循环)
      */
    for (int i = 0;i < lists.size();i++) {
        System.out.println(lists.get(i));
    }
    for (Integer i : lists) {
        System.out.println(i);
    }


    /**
      * 2.迭代器遍历
      */
    Iterator<Integer> iterator = lists.iterator();
    while (iterator.hasNext()) {
        System.out.println(iterator.next());
    }

    /**
      * 3.JDK8的stream流方式
      */
    lists.stream().forEach(System.out::println);
}

list.stream().distinct().forEach(System.out::println);

//不包含toIndex下标的元素，即左闭右开
public List<E> subList(int fromIndex, int toIndex) {
    subListRangeCheck(fromIndex, toIndex, size);
    return new SubList(this, 0, fromIndex, toIndex);
}
SubList(AbstractList<E> parent,
        int offset, int fromIndex, int toIndex) {
    this.parent = parent;
    this.parentOffset = fromIndex;
    this.offset = offset + fromIndex;
    this.size = toIndex - fromIndex;
    this.modCount = ArrayList.this.modCount;
}

private static class Node<E> {
    E item;        //元素
    Node<E> next;  //后继节点
    Node<E> prev;  //前置节点

    Node(Node<E> prev, E element, Node<E> next) {
        this.item = element;
        this.next = next;
        this.prev = prev;
    }
}

public LinkedList() {
}

//调用addAll方法，这个下面详说
public LinkedList(Collection<? extends E> c) {
    this();
    addAll(c);
}

//添加元素到链表末尾
//将元素包装成Node节点,然后就是链表的操作了
//	如果尾节点是空的,那么将该节点作为头和尾节点
//	如果尾节点非空,那么将该节点作为尾节点,并且加入到链表中
void linkLast(E e) {
    final Node<E> l = last;
    final Node<E> newNode = new Node<>(l, e, null);
    last = newNode;
    if (l == null)
        first = newNode;
    else
        l.next = newNode;
    size++;
    modCount++;
}
//添加元素到链表头
private void linkFirst(E e) {
    final Node<E> f = first;
    final Node<E> newNode = new Node<>(null, e, f);
    first = newNode;
    if (f == null)
        last = newNode;
    else
        f.prev = newNode;
    size++;
    modCount++;
}
//链表操作,将 e 插入到 succ 前面
void linkBefore(E e, Node<E> succ) {
    // succ 不能为null
    final Node<E> pred = succ.prev;
    final Node<E> newNode = new Node<>(pred, e, succ);
    succ.prev = newNode;
    if (pred == null)
        //即succ是头节点的情况
        first = newNode;
    else
        pred.next = newNode;
    size++;
    modCount++;
}
/**
 * 采用折半法得到index所在的位置(左/右区间)
 * 然后采用for循环遍历的方式得到index位置上的元素
 */
Node<E> node(int index) {
    if (index < (size >> 1)) {
        Node<E> x = first;
        for (int i = 0; i < index; i++)
            x = x.next;
        return x;
    } else {
        Node<E> x = last;
        //注意：这里是从后往前遍历
        for (int i = size - 1; i > index; i--)
            x = x.prev;
        return x;
    }
}

public boolean add(E e) {
    //插入链表的末尾
    linkLast(e);
    return true;
}

public void add(int index, E element) {
    //检查下标是否越界
    checkPositionIndex(index);
	
    if (index == size)
        //添加到链表最后,即调用上面的add(E e)方法
        linkLast(element);
    else
        //插入node(index)节点之前
        linkBefore(element, node(index));
}
//检查下标是否越界和index是否小于0
private void checkPositionIndex(int index) {
    if (!isPositionIndex(index))
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
private boolean isPositionIndex(int index) {
    return index >= 0 && index <= size;
}

public boolean addAll(Collection<? extends E> c) {
    return addAll(size, c);
}
public boolean addAll(int index, Collection<? extends E> c) {
    //检查下标是否越界
    checkPositionIndex(index);
	//得到指定插入的元素
    Object[] a = c.toArray();
    int numNew = a.length;
    if (numNew == 0)
        return false;
	//获取插入位置的前驱和后继节点
    Node<E> pred, succ;
    if (index == size) {
        succ = null;
        pred = last;
    } else {
        succ = node(index);
        pred = succ.prev;
    }
	//for循环插入指定元素,并且设置好上面的前驱和后继节点
    for (Object o : a) {
        E e = (E) o;
        Node<E> newNode = new Node<>(pred, e, null);
        if (pred == null)
            first = newNode;
        else
            pred.next = newNode;
        pred = newNode;
    }
    if (succ == null) {
        last = pred;
    } else {
        pred.next = succ;
        succ.prev = pred;
    }
    size += numNew;
    modCount++;
    return true;
}

//返回头节点元素内容
public E getFirst() {
    final Node<E> f = first;
    if (f == null)
        throw new NoSuchElementException();
    return f.item;
}
//返回尾节点元素内容
public E getLast() {
    final Node<E> l = last;
    if (l == null)
        throw new NoSuchElementException();
    return l.item;
}
//获取指定下标的元素
public E get(int index) {
    checkElementIndex(index);
    //折半for循环查找指定下标的元素
    return node(index).item;
}
//检查下标是否越界和index是否小于0
private void checkElementIndex(int index) {
    if (!isElementIndex(index))
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
private boolean isElementIndex(int index) {
    return index >= 0 && index < size;
}

//要求参数 x 不能为null
E unlink(Node<E> x) {
    //得到需要删除节点的内容、前驱节点和后继节点
    final E element = x.item;
    final Node<E> next = x.next;
    final Node<E> prev = x.prev;
	
    if (prev == null) {
        //该节点是头结点的情况
        first = next;
    } else {
        prev.next = next;
        x.prev = null;
    }

    if (next == null) {
        //该节点是尾节点的情况
        last = prev;
    } else {
        next.prev = prev;
        x.next = null;
    }
    x.item = null;
    size--;
    modCount++;
    return element;
}

private E unlinkFirst(Node<E> f) {
    // 要求f是头节点并且不为null
    final E element = f.item;
    final Node<E> next = f.next;
    f.item = null;
    f.next = null; // help GC
    first = next;
    if (next == null)
        //链表元素只有一个的情况
        last = null;
    else
        next.prev = null;
    size--;
    modCount++;
    return element;
}

private E unlinkLast(Node<E> l) {
    // 要求l是尾节点并且不为null
    final E element = l.item;
    final Node<E> prev = l.prev;
    l.item = null;
    l.prev = null; // help GC
    last = prev;
    if (prev == null)
        //链表元素只有一个的情况
        first = null;
    else
        prev.next = null;
    size--;
    modCount++;
    return element;
}

//删除指定元素的节点，利用for循环便利链表，找到第一个配对的元素删除
//注意：如果链表有多个相同的元素，该方法只会删除第一个
public boolean remove(Object o) {
    if (o == null) {
        for (Node<E> x = first; x != null; x = x.next) {
            if (x.item == null) {
                unlink(x);
                return true;
            }
        }
    } else {
        for (Node<E> x = first; x != null; x = x.next) {
            if (o.equals(x.item)) {
                unlink(x);
                return true;
            }
        }
    }
    return false;
}

public E set(int index, E element) {
    //检查下标是否越界或者index是否小于0
    checkElementIndex(index);
    //找到index下标的元素,更新该item内容后返回旧值
    Node<E> x = node(index);
    E oldVal = x.item;
    x.item = element;
    return oldVal;
}

public boolean add(E e) {
    final ReentrantLock lock = this.lock;
    //加锁操作
    lock.lock();
    try {
        Object[] elements = getArray();
        int len = elements.length;
        //复制一个新的数组，新增操作在新数组上完成
        Object[] newElements = Arrays.copyOf(elements, len + 1);
        newElements[len] = e;
        //将新数组设置到 array 上
        setArray(newElements);
        return true;
    } finally {
        lock.unlock();
    }
}

static final class COWIterator<E> implements ListIterator<E> {
    //原数组的副本
    private final Object[] snapshot;
    //游标
    private int cursor;
	//CopyOnWriteArrayList调用 iterator() 执行的构造函数
    private COWIterator(Object[] elements, int initialCursor) {
        cursor = initialCursor;
        snapshot = elements;
    }
    public boolean hasNext() {
        return cursor < snapshot.length;
    }
    public boolean hasPrevious() {
        return cursor > 0;
    }

    public E next() {
        if (! hasNext())
            throw new NoSuchElementException();
        return (E) snapshot[cursor++];
    }
    public E previous() {
        if (! hasPrevious())
            throw new NoSuchElementException();
        return (E) snapshot[--cursor];
    }
    public int nextIndex() {
        return cursor;
    }
    public int previousIndex() {
        return cursor-1;
    }
	//CopyOnWriteArrayList的迭代器不支持一下方法
    public void remove() {
        throw new UnsupportedOperationException();
    }
    public void set(E e) {
        throw new UnsupportedOperationException();
    }
    public void add(E e) {
        throw new UnsupportedOperationException();
    }
}

/**
 * redis实现分布式锁
 */
@Component
public class DistributedLock {
    @Autowired
    private JedisPool jedisPool;

    /**
     * 加锁
     * @param lockName 存放redis中的key
     * @param acquireTimeOut 分布式锁的过期时间
     * @param timeout 获取锁的超时时间
     * @return
     */
    public String lockWithTimeOut(String lockName, int acquireTimeOut, long timeout) {
        /**
         * 先setnx key是否成功;
         *      成功则设置随机值(UUID),然后设置过期时间,返回随机值给释放锁用
         *
         *      失败则计算获取锁的超时时间,时间未到则自旋获取锁直到成功或者达到超时时间
         */
        String identifier = UUID.randomUUID().toString().replaceAll("-", "");
        timeout = System.currentTimeMillis() + timeout;
        String reIdentifier = "";

        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            jedis.select(0);
            //带超时时间的循环获取锁实现锁阻塞特性
            while(System.currentTimeMillis() < timeout){
                Long setnx = jedis.setnx(lockName, identifier);
                if (setnx != null && setnx == 1){
                    //设置过期时间
                    jedis.expire(lockName, acquireTimeOut);
                    reIdentifier = identifier;
                    break;
                }else {
                  //这一步很重要   
                 //如果key已经存在,查看过期时间,如果该key无过期时间则重新设置过期时间,以免发生死锁
                    Long ttl = jedis.ttl(lockName);
                    if (ttl == -1){
                        jedis.expire(lockName, acquireTimeOut);
                    }
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        System.out.println("线程中断");
                        Thread.currentThread().interrupt();
                    }
                }
            }
        } catch (Exception e) {
            //TODO 处理异常
            e.printStackTrace();
        } finally {
            if (jedis != null)
                jedis.close();
        }
        return reIdentifier;
    }

    /**
     * 释放锁
     * @param lockName 锁的名称
     * @param identifier 锁的标识(用来验证锁中的val是否一致)
     * @return
     */
    public boolean releaseLock(String lockName, String identifier){
        Jedis jedis = null;
        boolean flag = false;
        try {
            jedis = jedisPool.getResource();
            jedis.select(0);
            jedis.watch(lockName);
            String result = jedis.get(lockName);
            if (result != null && identifier.equals(result)){
                Transaction multi = jedis.multi();
                multi.del(lockName);
                List<Object> exec = multi.exec();
                if (exec != null && exec.size() > 0){
                    flag = true;
                }
            }
            jedis.unwatch();
            return flag;
        } catch (Exception e) {
            //TODO 处理异常
            e.printStackTrace();
            return false;
        } finally {
            if (jedis != null)
                jedis.close();
        }
    }

}

/**
 * Zookeeper 实现分布式锁
 */
public class ZooKeeperLock implements Watcher {

    // ZK对象
    private ZooKeeper zk = null;
    // 分布式锁的根节点
    private String rootLockNode;
    // 竞争资源，用来生成子节点名称
    private String lockName;
    // 当前锁
    private String currentLock;
    // 等待的锁（前一个锁）
    private String waitLock;
    // 计数器（用来在加锁失败时阻塞加锁线程）
    private CountDownLatch countDownLatch;
    // 超时时间
    private int sessionTimeout = 30000;


    /**
     *  构造器中创建ZK链接，创建锁的根节点
     *
     * @param zkAddress     ZK的地址
     * @param rootLockNode  根节点名称
     * @param lockName      子节点名称
     */
    public ZooKeeperLock(String zkAddress, String rootLockNode, String lockName) {
        this.rootLockNode = rootLockNode;
        this.lockName = lockName;
        try {
            /**
             * 创建连接，zkAddress格式为：IP:PORT
             * watcher监听器为自身
             */
            zk = new ZooKeeper(zkAddress, this.sessionTimeout, this);
            /**
             * 检测锁的根节点是否存在，不存在则创建
             */
            Stat stat = zk.exists(rootLockNode, false);
            if (null == stat) {
                zk.create(rootLockNode, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } 
    }

    /**
     * 加锁方法，先尝试加锁，不能加锁则等待上一个锁的释放
     *
     * @return
     */
    public boolean lock() {
        if (this.tryLock()) {
            System.out.println("线程【" + Thread.currentThread().getName() + "】加锁（" + this.currentLock + "）成功！");
            return true;
        } else {
            return waitOtherLock(this.waitLock, this.sessionTimeout);
        }
    }

    public boolean tryLock() {
        // 分隔符
        String split = "_lock_";
        if (this.lockName.contains("_lock_")) {
            throw new RuntimeException("lockName can't contains '_lock_' ");
        }
        try {
            /**
             * 创建锁节点（临时有序节点）并且得到节点名称
             *
             * path: 根节点/子锁名称+分隔符
             */
            this.currentLock = zk.create(this.rootLockNode + "/" + this.lockName + split, new byte[0],
                    ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);

            System.out.println("线程【" + Thread.currentThread().getName()
                    + "】创建锁节点（" + this.currentLock + "）成功，开始竞争...");

            /**
             * 获取所有子节点
             */
            List<String> nodes = zk.getChildren(this.rootLockNode, false);
            /**
             * 获取所有正在竞争lockName的锁
             */
            List<String> lockNodes = new ArrayList<String>();
            for (String nodeName : nodes) {
                if (nodeName.split(split)[0].equals(this.lockName)) {
                    lockNodes.add(nodeName);
                }
            }
            Collections.sort(lockNodes);

            /**
             * 获取最小节点与当前锁节点比对加锁
             *
             *      比对最小节点的名称是否跟刚才创建的临时节点名称一致
             *      一致则证明当前加锁成功
             */
            String currentLockPath = this.rootLockNode + "/" + lockNodes.get(0);
            if (this.currentLock.equals(currentLockPath)) {
                return true;
            }

            /**
             * 加锁失败，设置前一节点为等待锁节点
             */
            String currentLockNode = this.currentLock.substring(this.currentLock.lastIndexOf("/") + 1);
            int preNodeIndex = Collections.binarySearch(lockNodes, currentLockNode) - 1;
            this.waitLock = lockNodes.get(preNodeIndex);

        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 等待获取锁，带超时时间
     *
     * @param waitLock          当前节点的前一个锁
     * @param sessionTimeout    等待获取锁的超时时间
     * @return
     */
    private boolean waitOtherLock(String waitLock, int sessionTimeout) {
        boolean islock = false;
        try {
            // 监听等待锁节点
            String waitLockNode = this.rootLockNode + "/" + waitLock;
            Stat stat = zk.exists(waitLockNode, true);
            if (null != stat) {
                System.out.println("线程【" + Thread.currentThread().getName()
                        + "】锁（" + this.currentLock + "）加锁失败，等待锁（" + waitLockNode + "）释放...");
                /**
                 * 设置计数器，使用计数器阻塞线程,带超时时间
                 */
                this.countDownLatch = new CountDownLatch(1);
                islock = this.countDownLatch.await(sessionTimeout, TimeUnit.MILLISECONDS);
                this.countDownLatch = null;
                if (islock) {
                    System.out.println("线程【" + Thread.currentThread().getName() + "】锁（"
                            + this.currentLock + "）加锁成功，锁（" + waitLockNode + "）已经释放");
                } else {
                    System.out.println("线程【" + Thread.currentThread().getName() + "】锁（"
                            + this.currentLock + "）加锁失败...");
                }
            } else {
                islock = true;
            }
        } catch (KeeperException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return islock;
    }

    /**
     * 释放分布式锁
     *
     * @throws InterruptedException
     */
    public void unlock() throws InterruptedException {
        try {
            Stat stat = zk.exists(this.currentLock, false);
            if (null != stat) {
                System.out.println("线程【" + Thread.currentThread().getName() + "】释放锁 " + this.currentLock);
                zk.delete(this.currentLock, -1);
                this.currentLock = null;
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (KeeperException e) {
            e.printStackTrace();
        } finally {
            zk.close();
        }
    }

    /**
     * 节点监听器回调
     *
     * @param watchedEvent
     */
    @Override
    public void process(WatchedEvent watchedEvent) {
        /**
         * 监听节点删除的事件
         *      计数器减一，恢复线程操作
         */
        if (null != this.countDownLatch && watchedEvent.getType() == Event.EventType.NodeDeleted) {
            this.countDownLatch.countDown();
        }
    }
}

/**
 * Curator 实现的分布式锁:
 *          InterProcessMutex:          分布式可重入排它锁
 *          InterProcessSemaphoreMutex: 分布式排它锁
 *          InterProcessReadWriteLock:  分布式读写锁
 *          InterProcessMultiLock:      将多个锁作为单个实体管理的容器
 */
public class CuratorLock {

    public static void main(String[] args) {
        /**
         * 设置重试策略，创建zk客户端
         * curator链接zookeeper的策略:ExponentialBackoffRetry
         *              baseSleepTimeMs：初始sleep的时间
         *              maxRetries：最大重试次数
         *              maxSleepMs：最大重试时间
         */
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000, 3);
        CuratorFramework client = 
            CuratorFrameworkFactory.newClient("127.0.0.1:2181", retryPolicy);
        // 启动客户端
        client.start();
        /**
         * 创建分布式可重入排他锁，监听客户端为client，锁的根节点为/locks
         */
        InterProcessMutex mutex = new InterProcessMutex(client, "/locks");
        try {
            /**
             * 加锁操作
             *     public boolean acquire(long time, TimeUnit unit)
             *          第一个参数是超时时间
             *          第二个参数是时间的单位
             */
            mutex.acquire(3, TimeUnit.SECONDS);

            /**
             * 释放锁
             */
            mutex.release();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            client.close();
        }
    }
}

/**
     * 获取请求的真实ip地址
     * @param request
     * @return
     */
    public String getRealIpAdrress(HttpServletRequest request) {
        String ipAdrress = "";
        String forwardFor = request.getHeader("X-Forwarded-For");
        if (!T.isBlank(forwardFor) && !"unKnown".equalsIgnoreCase(forwardFor)) {
            //多次反向代理后会有多个ip值，第一个ip才是真实ip
            int index = forwardFor.indexOf(",");
            if(index != -1){
                ipAdrress = forwardFor.substring(0,index);
            }else{
                ipAdrress = forwardFor;
            }
        }
        if (T.isBlank(ipAdrress) || "unKnown".equalsIgnoreCase(forwardFor)) {
            ipAdrress = request.getHeader("Proxy-Client-IP");
        }
        if (T.isBlank(ipAdrress) || "unKnown".equalsIgnoreCase(forwardFor)) {
            ipAdrress = request.getHeader("WL-Proxy-Client-IP");
        }
        if (T.isBlank(ipAdrress)) {
            ipAdrress = request.getHeader("X-Real-IP");
        }
        if (T.isBlank(ipAdrress) || "unKnown".equalsIgnoreCase(forwardFor)) {
            ipAdrress = request.getHeader("HTTP_CLIENT_IP");
        }
        if (T.isBlank(ipAdrress) || "unKnown".equalsIgnoreCase(forwardFor)) {
            ipAdrress = request.getHeader("HTTP_X_FORWARDED_FOR");
        }
        if (T.isBlank(ipAdrress) || "unKnown".equalsIgnoreCase(forwardFor)) {
            ipAdrress = request.getRemoteAddr();
        }
        return ipAdrress;
    }