public class Widget {
    public synchronized void doSomething() {
        ...
    }
}
public class LoggingWidget extends Widget {
    public synchronized void doSomething() {
        System.out.println(toString() + ": calling doSomething");
        super.doSomething();//若内置锁是不可重入的，则发生死锁
    }
}

public class SemaphoreDemo implements Runnable {
    //只有两个信号量
    final Semaphore semaphore = new Semaphore(2);
    static SemaphoreDemo demo = new SemaphoreDemo();
    public static void main(String[] args) {
        //有10个线程去抢夺
        ExecutorService executor = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 10; i++) {
            executor.submit(demo);
        }
    }
    @Override
    public void run() {
        try {
            //获得
            semaphore.acquire();
            Thread.sleep(1000);
            System.out.println("Thread " + Thread.currentThread().getId() + " done!");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            //释放
            semaphore.release();
        }
    }
}

public class CountDownLatchDemo implements Runnable {
    //5个任务需要检查
    static final CountDownLatch end = new CountDownLatch(5);
    static final CountDownLatchDemo demo = new CountDownLatchDemo();
    public static void main(String[] args) throws InterruptedException {
        //执行5个线程完成检查，如果没有完成，所有线程就会阻塞，等待完成
        // 所以线程的个数必须要与倒计时个数相同
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 5; i++) {
            executorService.submit(demo);
        }
        //等待通知
        end.await();
        System.out.println("Fired");
        executorService.shutdown();
    }
    @Override
    public void run() {
        Random r = new Random();
        try {
            Thread.sleep(r.nextInt(5) * 1000);
            end.countDown();
            System.out.println("chenk over, remaining "+end.getCount() );
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class CyclicBarrierDemo {
    public static class Soldier implements Runnable {
        private String soldier;
        private final CyclicBarrier cyclic;
        public Soldier(CyclicBarrier cyclic, String soldier) {
            this.soldier = soldier;
            this.cyclic = cyclic;
        }
        @Override
        public void run() {
            try {
                //复用栅栏
                //等待所有士兵到齐
                cyclic.await();
                doWork();
                //等待所有士兵完成工作
                cyclic.await();
            } catch (InterruptedException e) {//在等待过程中,线程被中断
                e.printStackTrace();
            } catch (BrokenBarrierException e) {//表示当前CyclicBarrier已经损坏.系统无法等到所有线程到齐了.
                e.printStackTrace();
            }
        }
        void doWork() {
            try {
                Thread.sleep(Math.abs(new Random().nextInt() % 10000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(soldier + ":任务完成");
        }
    }
    public static class BarrierRun implements Runnable {
        boolean flag;
        int N;
        public BarrierRun(boolean flag, int N) {
            this.flag = flag;
            this.N = N;
        }
        @Override
        public void run() {
            if (flag) {
                System.out.println("司令:[士兵" + N + "个,任务完成!]");
            } else {
                System.out.println("司令:[士兵" + N + "个,集合完毕!]");
                flag = true;
            }
        }
    }
    public static void main(String[] args) {
        final int N = 10;
        Thread[] allSoldier = new Thread[N];
        boolean flag = false;
        //第二个参数就是当计数器一次计数完成后，系统会执行的动作
        CyclicBarrier cyclic = new CyclicBarrier(N, new BarrierRun(flag, N));
        //设置屏障点,主要为了执行这个方法
        System.out.println("集合队伍! ");
        for (int i = 0; i < N; i++) {
            System.out.println("士兵" + i + "报道! ");
            allSoldier[i] = new Thread(new Soldier(cyclic, "士兵" + i));
            allSoldier[i].start();
//            if(i == 5){
//               allSoldier[i].interrupt();
//            }
        }
    }
}

private static class SynchronizedMap<K,V> implements Map<K,V>, Serializable{
    private final Map<K,V> m;     // Backing Map
    final Object      mutex;        // Object on which to synchronize
    public V get(Object key) {
       synchronized (mutex) {return m.get(key);}
    }
    public V put(K key, V value) {
       synchronized (mutex) {return m.put(key, value);}
    }
    public V remove(Object key) {
       synchronized (mutex) {return m.remove(key);}
    }
}

static final class HashEntry<K,V> {  
    final K key;  
    final int hash;  
    volatile V value;  
    final HashEntry<K,V> next;  
}

static final class Segment<K,V> extends ReentrantLock implements Serializable {  
private static final long serialVersionUID = 2249069246763182397L;  
     /**
      * The number of elements in this segment's region.
      */  
     transient volatile int count;  
     /**
      * Number of updates that alter the size of the table. This is
      * used during bulk-read methods to make sure they see a
      * consistent snapshot: If modCounts change during a traversal
      * of segments computing size or checking containsValue, then
      * we might have an inconsistent view of state so (usually)
      * must retry.
      */  
     transient int modCount;  
     /**
      * The table is rehashed when its size exceeds this threshold.
      * (The value of this field is always <tt>(int)(capacity *
      * loadFactor)</tt>.)
      */  
     transient int threshold;  
     /**
      * The per-segment table.
      */  
     transient volatile HashEntry<K,V>[] table;  
     /**
      * The load factor for the hash table.  Even though this value
      * is same for all segments, it is replicated to avoid needing
      * links to outer object.
      * @serial
      */  
     final float loadFactor;  
}

V get(Object key, int hash) {  
    if (count != 0) { // read-volatile  
        HashEntry<K,V> e = getFirst(hash);  
        while (e != null) {  
            if (e.hash == hash && key.equals(e.key)) {  
                V v = e.value;  
                if (v != null)  
                    return v;  
                return readValueUnderLock(e); // recheck  
            }  
            e = e.next;  
        }  
    }  
    return null;  
}

V put(K key, int hash, V value, boolean onlyIfAbsent) {  
    lock();  
    try {  
        int c = count;  
        if (c++ > threshold) // ensure capacity  
            rehash();  
        HashEntry<K,V>[] tab = table;  
        int index = hash & (tab.length - 1);  
        HashEntry<K,V> first = tab[index];  
        HashEntry<K,V> e = first;  
        while (e != null && (e.hash != hash || !key.equals(e.key)))  
            e = e.next;  
        V oldValue;  
        if (e != null) {  
            oldValue = e.value;  
            if (!onlyIfAbsent)  
                e.value = value;  
        }  
        else {  
            oldValue = null;  
            ++modCount;  
            tab[index] = new HashEntry<K,V>(key, hash, first, value);  
            count = c; // write-volatile  
        }  
        return oldValue;  
    } finally {  
        unlock();  
    }  
}

V remove(Object key, int hash, Object value) {  
    lock();  
    try {  
        int c = count - 1;  
        HashEntry<K,V>[] tab = table;  
        int index = hash & (tab.length - 1);  
        HashEntry<K,V> first = tab[index];  
        HashEntry<K,V> e = first;  
        while (e != null && (e.hash != hash || !key.equals(e.key)))  
            e = e.next;  
        V oldValue = null;  
        if (e != null) {  
            V v = e.value;  
            if (value == null || value.equals(v)) {  
                oldValue = v;  
                // All entries following removed node can stay  
                // in list, but all preceding ones need to be  
                // cloned.  
                ++modCount;  
                HashEntry<K,V> newFirst = e.next;  
                //复制
                for (HashEntry<K,V> p = first; p != e; p = p.next)  
                    newFirst = new HashEntry<K,V>(p.key, p.hash,  
                                                  newFirst, p.value);  
                tab[index] = newFirst;  
                count = c; // write-volatile  
            }  
        }  
        return oldValue;  
    } finally {  
        unlock();  
    }  
}

class Producer implements Runnable {
  private final BlockingQueue queue;
  Producer(BlockingQueue q) { queue = q; }
  public void run() {
    try {
      while (true) { queue.put(produce()); }
    } catch (InterruptedException ex) { ... handle ...}
  }
  Object produce() { ... }
}
class Consumer implements Runnable {
  private final BlockingQueue queue;
  Consumer(BlockingQueue q) { queue = q; }
  public void run() {
    try {
      while (true) { consume(queue.take()); }
    } catch (InterruptedException ex) { ... handle ...}
  }
  void consume(Object x) { ... }
}
class Setup {
  void main() {
    BlockingQueue q = new SomeQueueImplementation();
    Producer p = new Producer(q);
    Consumer c1 = new Consumer(q);
    Consumer c2 = new Consumer(q);
    new Thread(p).start();
    new Thread(c1).start();
    new Thread(c2).start();
  }
}

/** Main lock guarding all access */
final ReentrantLock lock;
/** Condition for waiting takes */
private final Condition notEmpty;
/** Condition for waiting puts */
private final Condition notFull;
/** The queued items */
final Object[] items;

public void put(E e) throws InterruptedException {
    checkNotNull(e);
    //加锁
    final ReentrantLock lock = this.lock;
    //响应阻塞
    lock.lockInterruptibly();
    try {
        while (count == items.length)
            //队列满就等待
            notFull.await();
        enqueue(e);
    } finally {
      //释放锁
        lock.unlock();
    }
}
/**
* Inserts element at current put position, advances, and signals.
* Call only when holding lock.
*/
private void enqueue(E x) {
    // assert lock.getHoldCount() == 1;
    // assert items[putIndex] == null;
    final Object[] items = this.items;
    items[putIndex] = x;
    if (++putIndex == items.length)
        putIndex = 0;
    count++;
    //通知不空
    notEmpty.signal();
}

/** Current number of elements */
private final AtomicInteger count = new AtomicInteger();
/** Lock held by take, poll, etc */
private final ReentrantLock takeLock = new ReentrantLock();
/** Lock held by put, offer, etc */
private final ReentrantLock putLock = new ReentrantLock();
/** Wait queue for waiting takes */
private final Condition notEmpty = takeLock.newCondition();
/** Wait queue for waiting puts */
private final Condition notFull = putLock.newCondition();
/** Linked list node class */
static class Node<E> {
    E item;
    Node<E> next;
    Node(E x) { item = x; }
}

public void put(E e) throws InterruptedException {
    if (e == null) throw new NullPointerException();
    // Note: convention in all put/take/etc is to preset local var
    // holding count negative to indicate failure unless set.
    int c = -1;
    Node<E> node = new Node<E>(e);
    final ReentrantLock putLock = this.putLock;
    final AtomicInteger count = this.count;
    putLock.lockInterruptibly();
    try {
        /*
         * Note that count is used in wait guard even though it is
         * not protected by lock. This works because count can
         * only decrease at this point (all other puts are shut
         * out by lock), and we (or some other waiting put) are
         * signalled if it ever changes from capacity. Similarly
         * for all other uses of count in other wait guards.
         */
        while (count.get() == capacity) {
            notFull.await();
        }
        enqueue(node);
        c = count.getAndIncrement();
        if (c + 1 < capacity)
            notFull.signal();
    } finally {
        putLock.unlock();
    }
    if (c == 0)
        signalNotEmpty();
}

private transient volatile Node<E> head;
private transient volatile Node<E> tail;
private static class Node<E> {
      volatile E item;
      volatile Node<E> next;
      ...
}

public class CopyOnWriteArrayList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
  /** The lock protecting all mutators */
  final transient ReentrantLock lock = new ReentrantLock();
  /** The array, accessed only via getArray/setArray. */
  private transient volatile Object[] array;
  ...
}

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;
        setArray(newElements);
        return true;
    } finally {
        lock.unlock();
    }
}

public E get(int index) {
         return (E) a[index];
}