//创建并发访问的账户
MyCount myCount = new MyCount("95599200901215522", 10000);
//创建一个锁对象
Lock lock = new ReentrantLock();
//创建一个线程池
ExecutorService pool = Executors.newCachedThreadPool();
//创建一些并发访问用户, 一个信用卡, 存的存, 取的取, 好热闹啊
User u1 = new User("张三", myCount, -4000, lock);
User u2 = new User("张三他爹", myCount, 6000, lock);
User u3 = new User("张三他弟", myCount, -8000, lock);
User u4 = new User("张三", myCount, 800, lock);
//在线程池中执行各个用户的操作
pool.execute(u1);
pool.execute(u2);
pool.execute(u3);
pool.execute(u4);
//关闭线程池
pool.shutdown();

/**
 * 信用卡的用户
 */
class User implements Runnable {
  private String name;                //用户名
  private MyCount myCount;        //所要操作的账户
  private int iocash;                 //操作的金额, 当然有正负之分了
  private Lock myLock;                //执行操作所需的锁对象
  User(String name, MyCount myCount, int iocash, Lock myLock) {
    this.name = name;
    this.myCount = myCount;
    this.iocash = iocash;
    this.myLock = myLock;
  }
  public void run() {
    //获取锁
    myLock.lock();
    //执行现金业务
    System.out.println(name + "正在操作" + myCount + "账户, 金额为" + iocash + ", 当前金额为" + myCount.getCash());
    myCount.setCash(myCount.getCash() + iocash);
    System.out.println(name + "操作" + myCount + "账户成功, 金额为" + iocash + ", 当前金额为" + myCount.getCash());
    //释放锁, 否则别的线程没有机会执行了
    myLock.unlock();
  }
}

/**
 * 信用卡账户, 可随意透支
 */
class MyCount {
  private String oid;         //账号
  private int cash;             //账户余额
  MyCount(String oid, int cash) {
          this.oid = oid;
          this.cash = cash;
  }
  public String getOid() {
          return oid;
  }
  public void setOid(String oid) {
          this.oid = oid;
  }
  public int getCash() {
          return cash;
  }
  public void setCash(int cash) {
          this.cash = cash;
  }
  @Override
  public String toString() {
    return "MyCount{" +
                    "oid='" + oid + '\'' +
                    ", cash=" + cash +
                    '}';
  }
}

volatile boolean isProcess = false;
ReentrantLock lock  = new ReentrantLock();
Condition processReady = lock.newCondition();
thread: run() {
    lock.lock();
    isProcess = true;
   try {
    while(!isProcessReady) {  
    //isProcessReady 是另外一个线程的控制变量
      processReady.await();
      //释放了lock，在此等待signal
     }catch (InterruptedException e) {
          Thread.currentThread().interrupt();
        } finally {
          lock.unlock();
          isProcess = false;
        }
      }
    }
}

public class Test {
    private Lock lock = new ReentrantLock();
    public static void main(String[] args)  {
        Test test = new Test();
        MyThread thread1 = new MyThread(test);
        MyThread thread2 = new MyThread(test);
        thread1.start();
        thread2.start();
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        thread2.interrupt();
    }      
    public void insert(Thread thread) throws InterruptedException{
        lock.lockInterruptibly();   
        //注意，如果需要正确中断等待锁的线程，必须将获取锁放在外面，然后将InterruptedException抛出
        try {   
            System.out.println(thread.getName()+"得到了锁");
            long startTime = System.currentTimeMillis();
            for(    ;     ;) {
                if(System.currentTimeMillis() - startTime >= Integer.MAX_VALUE)
                    break;
                //插入数据
            }
        }finally {
            System.out.println(Thread.currentThread().getName()+"执行finally");
            lock.unlock();
            System.out.println(thread.getName()+"释放了锁");
        }   
    }
}
class MyThread extends Thread {
    private Test test = null;
    public MyThread(Test test) {
        this.test = test;
    }
    @Override
    public void run() {       
        try {
            test.insert(Thread.currentThread());
        } catch (InterruptedException e) {
            System.out.println(Thread.currentThread().getName()+"被中断");
        }
    }
}

public interface ReadWriteLock {
    /**
     * Returns the lock used for reading.
     *
     * @return the lock used for reading.
     */
    Lock readLock();
   /**
    * Returns the lock used for writing.
    *
    * @return the lock used for writing.
    */
   Lock writeLock();
}

//创建并发访问的账户
MyCount myCount = new MyCount("95599200901215522", 10000);
//创建一个锁对象
ReadWriteLock lock = new ReentrantReadWriteLock(false);
//创建一个线程池
ExecutorService pool = Executors.newFixedThreadPool(2);
//创建一些并发访问用户, 一个信用卡, 存的存, 取的取, 好热闹啊
User u1 = new User("张三", myCount, -4000, lock, false);
User u2 = new User("张三他爹", myCount, 6000, lock, false);
User u3 = new User("张三他弟", myCount, -8000, lock, false);
User u4 = new User("张三", myCount, 800, lock, false);
User u5 = new User("张三他爹", myCount, 0, lock, true);
//在线程池中执行各个用户的操作
pool.execute(u1);
pool.execute(u2);
pool.execute(u3);
pool.execute(u4);
pool.execute(u5);
//关闭线程池
pool.shutdown();

/**
 * 信用卡的用户
 */
class User implements Runnable {
  private String name;                //用户名
  private MyCount myCount;        //所要操作的账户
  private int iocash;                 //操作的金额, 当然有正负之分了
  private ReadWriteLock myLock;                //执行操作所需的锁对象
  private boolean ischeck;        //是否查询
  User(String name, MyCount myCount, int iocash, ReadWriteLock myLock, boolean ischeck) {
          this.name = name;
          this.myCount = myCount;
          this.iocash = iocash;
          this.myLock = myLock;
          this.ischeck = ischeck;
  }
  public void run() {
    if (ischeck) {
            //获取读锁
            myLock.readLock().lock();
            System.out.println("读：" + name + "正在查询" + myCount + "账户, 当前金额为" + myCount.getCash());
            //释放读锁
            myLock.readLock().unlock();
    } else {
            //获取写锁
            myLock.writeLock().lock();
            //执行现金业务
            System.out.println("写：" + name + "正在操作" + myCount + "账户, 金额为" + iocash + ", 当前金额为" + myCount.getCash());
            myCount.setCash(myCount.getCash() + iocash);
            System.out.println("写：" + name + "操作" + myCount + "账户成功, 金额为" + iocash + ", 当前金额为" + myCount.getCash());
            //释放写锁
            myLock.writeLock().unlock();
    }
  }
}

/**
 * 信用卡账户, 可随意透支
 */
class MyCount {
        private String oid;         //账号
        private int cash;             //账户余额
        MyCount(String oid, int cash) {
                this.oid = oid;
                this.cash = cash;
        }
        public String getOid() {
                return oid;
        }
        public void setOid(String oid) {
                this.oid = oid;
        }
        public int getCash() {
                return cash;
        }
        public void setCash(int cash) {
                this.cash = cash;
        }
        @Override
        public String toString() {
          return "MyCount{" +
                          "oid='" + oid + '\'' +
                          ", cash=" + cash +
                          '}';
        }
}

//创建并发访问的账户
MyCount myCount = new MyCount("95599200901215522", 10000);
//创建一个线程池
ExecutorService pool = Executors.newFixedThreadPool(2);
Thread t1 = new SaveThread("张三", myCount, 2000);
Thread t2 = new SaveThread("李四", myCount, 3600);
Thread t3 = new DrawThread("王五", myCount, 2700);
Thread t4 = new SaveThread("老张", myCount, 600);
Thread t5 = new DrawThread("老牛", myCount, 1300);
Thread t6 = new DrawThread("胖子", myCount, 800);
//执行各个线程
pool.execute(t1);
pool.execute(t2);
pool.execute(t3);
pool.execute(t4);
pool.execute(t5);
pool.execute(t6);
//关闭线程池
pool.shutdown();

/**
 * 存款线程类
 */
class SaveThread extends Thread {
  private String name;     //操作人
  private MyCount myCount; //账户
  private int x;   //存款金额
  SaveThread(String name, MyCount myCount, int x) {
    this.name = name;
    this.myCount = myCount;
    this.x = x;
  }
  public void run() {
    myCount.saving(x, name);
  }
}

/**
 * 取款线程类
 */
class DrawThread extends Thread {
  private String name; //操作人
  private MyCount myCount; //账户
  private int x; //存款金额
  DrawThread(String name, MyCount myCount, int x) {
    this.name = name;
    this.myCount = myCount;
    this.x = x;
  }
  public void run() {
    myCount.drawing(x, name);
  }
}
/**
 * 普通银行账户, 不可透支
 */
class MyCount {
  private String oid;                         //账号
  private int cash;                             //账户余额
  private Lock lock = new ReentrantLock();                //账户锁
  private Condition _save = lock.newCondition();    //存款条件
  private Condition _draw = lock.newCondition();    //取款条件
  MyCount(String oid, int cash) {
    this.oid = oid;
    this.cash = cash;
  }
  /**
    * 存款
    *
    * @param x        操作金额
    * @param name 操作人
    */
  public void saving(int x, String name) {
    lock.lock();                        //获取锁
    if (x > 0) {
      cash += x;                    //存款
      System.out.println(name + "存款" + x + ", 当前余额为" + cash);
    }
    _draw.signalAll();            //唤醒所有等待线程.
    lock.unlock();                    //释放锁
  }
  /**
    * 取款
    *
    * @param x        操作金额
    * @param name 操作人
    */
  public void drawing(int x, String name) {
    lock.lock();                                 //获取锁
    try {
          if (cash - x < 0) {
            _draw.await();             //阻塞取款操作
          } else {
            cash -= x;                     //取款
            System.out.println(name + "取款" + x + ", 当前余额为" + cash);
          }
          _save.signalAll();             //唤醒所有存款操作
    } catch (InterruptedException e) {
            e.printStackTrace();
    } finally {
            lock.unlock();                     //释放锁
    }
  }
}

public void countDown()

递减锁存器的计数，如果计数到达零，则释放所有等待的线程。如果当前计数大于零，则将计数减少。
如果新的计数为零，出于线程调度目的，将重新启用所有的等待线程。

如果当前计数等于零，则不发生任何操作。

public boolean await(long timeout,
                     TimeUnit unit)
              throws InterruptedException

使当前线程在锁存器倒计数至零之前一直等待，除非线程被中断或超出了指定的等待时间。
如果当前计数为零，则此方法立刻返回 true 值。
如果当前计数大于零，则出于线程调度目的，将禁用当前线程，
且在发生以下三种情况之一前，该线程将一直处于休眠状态：

由于调用 countDown() 方法，计数到达零；或者其他某个线程中断当前线程；
或者已超出指定的等待时间。

如果计数到达零，则该方法返回 true 值。

如果当前线程：

在进入此方法时已经设置了该线程的中断状态；或者在等待时被中断，
则抛出 InterruptedException，并且清除当前线程的已中断状态。
如果超出了指定的等待时间，则返回值为 false。如果该时间小于等于零，则此方法根本不会等待。

参数：
    timeout - 要等待的最长时间
    unit - timeout 参数的时间单位。
返回：
    如果计数到达零，则返回 true；如果在计数到达零之前超过了等待时间，则返回 false
抛出：
    InterruptedException - 如果当前线程在等待时被中断

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

public class Test {
  public static void main(String[] args) {
    MyPool myPool = new MyPool(20);
    //创建线程池
    ExecutorService threadPool = Executors.newFixedThreadPool(2);
    MyThread t1 = new MyThread("任务A", myPool, 3);
    MyThread t2 = new MyThread("任务B", myPool, 12);
    MyThread t3 = new MyThread("任务C", myPool, 7);
    //在线程池中执行任务
    threadPool.execute(t1);
    threadPool.execute(t2);
    threadPool.execute(t3);
    //关闭池
    threadPool.shutdown();
  }
}

/**
 * 一个池
 */
class MyPool {
  private Semaphore sp;     //池相关的信号量
  /**
    * 池的大小, 这个大小会传递给信号量
    * @param size 池的大小
    */
  MyPool(int size) {
    this.sp = new Semaphore(size);
  }
  public Semaphore getSp() {
    return sp;
  }
  public void setSp(Semaphore sp) {
    this.sp = sp;
  }
}

class MyThread extends Thread {
  private String threadname;            //线程的名称
  private MyPool pool;                        //自定义池
  private int x;                                    //申请信号量的大小
  MyThread(String threadname, MyPool pool, int x) {
    this.threadname = threadname;
    this.pool = pool;
    this.x = x;
  }
  public void run() {
    try {
      //从此信号量获取给定数目的许可
      pool.getSp().acquire(x);
      //TODO 也许这里可以做更复杂的业务
      System.out.println(threadname + "成功获取了" + x + "个许可！");
    } catch (InterruptedException e) {
      e.printStackTrace();
    } finally {
      //释放给定数目的许可, 将其返回到信号量.
      pool.getSp().release(x);
      System.out.println(threadname + "释放了" + x + "个许可！");
    }
  }
}

//原子量, 每个线程都可以自由操作
private static AtomicLong aLong = new AtomicLong(10000);
lock.lock();
System.out.println(name + "执行了" + x + ", 当前余额：" + aLong.addAndGet(x));
lock.unlock();

class MyClass {
    public synchronized void method1() {
        method2();
    }
    public synchronized void method2() {
    }
}

ReentrantLock lock = new ReentrantLock(true);

//创建一个可重用固定线程数的线程池
ExecutorService pool = Executors.newFixedThreadPool(2);
//创建实现了Runnable接口对象, Thread对象当然也实现了Runnable接口
Thread t1 = new MyThread();
Thread t2 = new MyThread();
Thread t3 = new MyThread();
Thread t4 = new MyThread();
Thread t5 = new MyThread();
//将线程放入池中进行执行
pool.execute(t1);
pool.execute(t2);
pool.execute(t3);
pool.execute(t4);
pool.execute(t5);
//虽然放入了5个Runnable, 但必须在两个线程中循环执行. 
//关闭线程池
pool.shutdown();

ExecutorService pool = Executors.newSingleThreadExecutor();

ExecutorService pool = Executors.newCachedThreadPool();

//创建一个线程池, 它可安排在给定延迟后运行命令或者定期地执行.
ScheduledExecutorService pool = Executors.newScheduledThreadPool(2);
Thread t1 = new MyThread();
Thread t2 = new MyThread();
Thread t3 = new MyThread();
Thread t4 = new MyThread();
Thread t5 = new MyThread();
//将线程放入池中进行执行
pool.execute(t1);
pool.execute(t2);
pool.execute(t3);

//使用延迟执行风格的方法
pool.schedule(t4, 10, TimeUnit.MILLISECONDS);
pool.schedule(t5, 10, TimeUnit.MILLISECONDS);

//关闭线程池
pool.shutdown();

//创建一个单线程执行程序, 它可安排在给定延迟后运行命令或者定期地执行.
ScheduledExecutorService pool = Executors.newSingleThreadScheduledExecutor();

//创建等待队列
BlockingQueue<Runnable> bqueue = new ArrayBlockingQueue<Runnable>(20);
//创建一个单线程执行程序, 它可安排在给定延迟后运行命令或者定期地执行.
ThreadPoolExecutor pool = new ThreadPoolExecutor(2,3,2,TimeUnit.MILLISECONDS,bqueue);

ThreadPoolExecutor
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue)

public static ExecutorService newFixedThreadPool(int nThreads) {
  return new ThreadPoolExecutor(nThreads, nThreads,
                                            0L, TimeUnit.MILLISECONDS,
                                            new LinkedBlockingQueue<Runnable>());
}

public static ExecutorService newSingleThreadExecutor() {
  return new FinalizableDelegatedExecutorService
                (new ThreadPoolExecutor(1, 1,
                                         0L, TimeUnit.MILLISECONDS,
                                         new LinkedBlockingQueue<Runnable>()));
}

public static ExecutorService newCachedThreadPool() {
  return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                          60L, TimeUnit.SECONDS,
                                          new SynchronousQueue<Runnable>());
 }

new ThreadPoolExecutor(
        2, 3, 30, TimeUnit.SECONDS,
                 new  SynchronousQueue<Runnable>(),
                new RecorderThreadFactory("CookieRecorderPool"),
         new ThreadPoolExecutor.CallerRunsPolicy());

new ThreadPoolExecutor(
    2, 4, 30, TimeUnit.SECONDS,
    new ArrayBlockingQueue<Runnable>(2),
    new RecorderThreadFactory("CookieRecorderPool"),
    new ThreadPoolExecutor.CallerRunsPolicy());

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
           if (!e.isShutdown()) {
               r.run();
           }
       }

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
           throw new RejectedExecutionException();
       }

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
       }

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
           if (!e.isShutdown()) {
               e.getQueue().poll();
               e.execute(r);
           }
       }

public static ExecutorService newFixedThreadPool(int nThreads) {
       return new ThreadPoolExecutor(nThreads, nThreads,
                                     0L, TimeUnit.MILLISECONDS,
                                     new LinkedBlockingQueue<Runnable>());
   }

//创建一个线程池
ExecutorService pool = Executors.newFixedThreadPool(2);
//创建两个有返回值的任务
Callable c1 = new MyCallable("A");
Callable c2 = new MyCallable("B");
//执行任务并获取Future对象
Future f1 = pool.submit(c1);
Future f2 = pool.submit(c2);
//从Future对象上获取任务的返回值, 并输出到控制台
System.out.println(">>>"+f1.get().toString());
System.out.println(">>>"+f2.get().toString());
//关闭线程池
pool.shutdown();

class MyCallable implements Callable{

}

import java.util.concurrent.Semaphore;

/**
 * A、B两个线程轮流输出1~100的数字<br/>
 * A线程输出: 1、3、5...47、49、    52、54...98、100 <br/>
 * B线程输出: 2、4、6...48、50、51、53、55...97、99 两个线程输出个数相同
 */
public class RunningInTurn {
    /**
     * 每个线程 
     */
    static class Worker extends Thread {
        private final String name;
        private final Semaphore thisSemaphore;
        private final Semaphore nextSemaphore;
        private int value;

        public Worker(String name, Semaphore thisSemaphore, Semaphore nextSemaphore, int initialValue) {
            this.name = name;
            this.thisSemaphore = thisSemaphore;
            this.nextSemaphore = nextSemaphore;
            this.value = initialValue;
        }

        @Override
        public void run() {
            int cnt = 0;
            while (value <= 100) {
                try {
                    thisSemaphore.acquire();
                    System.out.println(name + ":\t" + value);
                    cnt++;
                    if (value == 50) {
                        value = 51;
                        System.out.println(name + ":\t" + value);
                        cnt++;
                        value += 2;
                    } else if (value == 49) {
                        value = 52;
                    } else {
                        value += 2;
                    }
                    nextSemaphore.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(name + " cnt : " + cnt);
        }
    }

    public static void main(String[] args) throws InterruptedException {

        Semaphore aSemaphore = new Semaphore(1);
        Semaphore bSemaphore = new Semaphore(1);
        Worker workerA = new Worker("a", aSemaphore, bSemaphore, 1);
        Worker workerB = new Worker("b", bSemaphore, aSemaphore, 2);
        bSemaphore.acquire();
        workerA.start();
        workerB.start();
    }

}

public interface Runnable {
    public void run();
}

public Thread(Runnable target) {
//
}
public Thread(String name) {
//
}
//由于 Thread 实现了 Runnable 接口,
//这种形式也可以以 Thread 对象为参数

try{
  Thread.sleep();
}catch(Exception e){
}
//原始定义
public static native void sleep(long millis) throws InterruptedException;

public synchronized void function(){
}

synchronized(object1){
}

while (!condition) {
     obj.wait();
}

B.join(1000);  

/**
* Waits at most {@code millis} milliseconds for this thread to
* die. A timeout of {@code 0} means to wait forever.
*
* <p> This implementation uses a loop of {@code this.wait} calls
* conditioned on {@code this.isAlive}. As a thread terminates the
* {@code this.notifyAll} method is invoked. It is recommended that
* applications not use {@code wait}, {@code notify}, or
* {@code notifyAll} on {@code Thread} instances.
*
* @param  millis
*         the time to wait in milliseconds
*
* @throws  IllegalArgumentException
*          if the value of {@code millis} is negative
*
* @throws  InterruptedException
*          if any thread has interrupted the current thread. The
*          <i>interrupted status</i> of the current thread is
*          cleared when this exception is thrown.
*/
public final synchronized void join(long millis)
throws InterruptedException {
    long base = System.currentTimeMillis();
    long now = 0;

    if (millis < 0) {
        throw new IllegalArgumentException("timeout value is negative");
    }

    if (millis == 0) {
        while (isAlive()) {
            wait(0);
        }
    } else {
        while (isAlive()) {
            long delay = millis - now;
            if (delay <= 0) {
                break;
            }
            wait(delay);
            now = System.currentTimeMillis() - base;
        }
    }
}

static Thread currentThread()
        返回对当前正在执行的线程对象的引用.
ClassLoader getContextClassLoader()
        返回该线程的上下文 ClassLoader.
Thread.State getState()
        返回该线程的状态.
ThreadGroup getThreadGroup()
        返回该线程所属的线程组.
static boolean holdsLock(Object obj)
        当且仅当当前线程在指定的对象上保持监视器锁时, 才返回 true.
static void setDefaultUncaughtExceptionHandler(Thread.UncaughtExceptionHandler eh)
          设置当线程”由于未捕获到异常而突然终止, 并且没有为该线程定义其他处理程序时”所调用的默认处理程序.
void stop()
        已过时.
        stop 的许多使用都应由只修改某些变量以指示目标线程应该停止运行的代码来取代.
        目标线程应定期检查该变量, 并且如果该变量指示它要停止运行,  则从其运行方法依次返回.
        如果目标线程等待很长时间（例如基于一个条件变量）,  则应使用 interrupt 方法来中断该等待.

//中断线程（实例方法）
public void Thread.interrupt();

//判断线程是否被中断（实例方法）
public boolean Thread.isInterrupted();

//判断是否被中断并清除当前中断状态（静态方法）
public static boolean Thread.interrupted();

public class InterruptSleepThread3 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread() {
            @Override
            public void run() {
                //while在try中，通过异常中断就可以退出run循环
                try {
                    while (true) {
                        //当前线程处于阻塞状态，异常必须捕捉处理，无法往外抛出
                        TimeUnit.SECONDS.sleep(2);
                    }
                } catch (InterruptedException e) {
                    System.out.println("Interruted When Sleep");
                    boolean interrupt = this.isInterrupted();
                    //中断状态被复位
                    System.out.println("interrupt:"+interrupt);
                }
            }
        };
        t1.start();
        TimeUnit.SECONDS.sleep(2);
        //中断处于阻塞状态的线程
        t1.interrupt();

        /**
         * 输出结果:
           Interruted When Sleep
           interrupt:false
         */
    }
}

public class InterruputThread {
    public static void main(String[] args) throws InterruptedException {
        Thread t1=new Thread(){
            @Override
            public void run(){
                while(true){
                    System.out.println("未被中断");
                }
            }
        };
        t1.start();
        TimeUnit.SECONDS.sleep(2);
        t1.interrupt();

        /**
         * 输出结果(无限执行):
             未被中断
             未被中断
             未被中断
             ......
         */
    }
}

public class InterruputThread {
    public static void main(String[] args) throws InterruptedException {
        Thread t1=new Thread(){
            @Override
            public void run(){
                while(true){
                    //判断当前线程是否被中断
                    if (this.isInterrupted()){
                        System.out.println("线程中断");
                        break;
                    }
                }

                System.out.println("已跳出循环,线程中断!");
            }
        };
        t1.start();
        TimeUnit.SECONDS.sleep(2);
        t1.interrupt();
        /**
         * 输出结果:
            线程中断
            已跳出循环,线程中断!
         */
    }
}

public void run(){
    try {
    //判断当前线程是否已中断,注意interrupted方法是静态的,执行后会对中断状态进行复位
    while (!Thread.interrupted()) {
        TimeUnit.SECONDS.sleep(2);
    }
    } catch (InterruptedException e) {

    }
}

/**
* Created by zejian on 2017/6/2.
* Blog : http://blog.csdn.net/javazejian [原文地址,请尊重原创]
*/
public class SynchronizedBlocked implements Runnable{

    public synchronized void f() {
        System.out.println("Trying to call f()");
        while(true){ // Never releases lock
            Thread.yield();
        }
    }

    /**
    * 在构造器中创建新线程并启动获取对象锁
    */
    public SynchronizedBlocked() {
        //该线程已持有当前实例锁
        new Thread() {
            public void run() {
                f(); // Lock acquired by this thread
            }
        }.start();
    }
    public void run() {
        //中断判断
        while (true) {
            if (Thread.interrupted()) {
                System.out.println("中断线程!!");
                break;
            } else {
                f();
            }
        }
    }


    public static void main(String[] args) throws InterruptedException {
        SynchronizedBlocked sync = new SynchronizedBlocked();
        Thread t = new Thread(sync);
        //启动后调用f()方法,无法获取当前实例锁处于等待状态
        t.start();
        TimeUnit.SECONDS.sleep(1);
        //中断线程,无法生效
        t.interrupt();
    }
}

final CountDownLatch countDownLatch = new CountDownLatch(2); //等待2次countdown
final Thread ta = new Thread(() -> {
  doWork("A");
  countDownLatch.countDown();
});
final Thread tb = new Thread(() -> {
  doWork("B");
  countDownLatch.countDown();
});
final Thread tc = new Thread(() -> {
  try {
    countDownLatch.await();
  } catch (final InterruptedException e1) {
    e1.printStackTrace();
  }
  doWork("C");
});
ta.start();
tb.start();
tc.start();

protected boolean tryAcquire(int arg) {
  throw new UnsupportedOperationException();
}

protected boolean tryRelease(int arg) {
  throw new UnsupportedOperationException();
}

protected int tryAcquireShared(int arg) {
  throw new UnsupportedOperationException();
}

protected boolean tryReleaseShared(int arg) {
  throw new UnsupportedOperationException();
}
protected boolean isHeldExclusively() {
  throw new UnsupportedOperationException();
}

protected int tryAcquireShared(int acquires) {
  return (getState() == 0) ? 1 : -1;
}

private volatile int state;

private void doAcquireSharedInterruptibly(int arg)
        throws InterruptedException {
    	//加入等待队列 				      
        final Node node = addWaiter(Node.SHARED);
        boolean failed = true;
    	// 进入 CAS 循环
        try {
            for (;;) {
                //当一个节点(关联一个线程)进入等待队列后， 获取此节点的 prev 节点 
                final Node p = node.predecessor();
                // 如果获取到的 prev 是 head，也就是队列中第一个等待线程
                if (p == head) {
                    // 再次尝试申请 反应到 CountDownLatch 就是查看是否还有线程需要等待(state是否为0)
                    int r = tryAcquireShared(arg);
                    // 如果 r >=0 说明 没有线程需要等待了 state==0
                    if (r >= 0) {
                        //尝试将第一个线程关联的节点设置为 head 
                        setHeadAndPropagate(node, r);
                        p.next = null; // help GC
                        failed = false;
                        return;
                    }
                }
                //经过自旋tryAcquireShared后，state还不为0，就会到这里，第一次的时候，waitStatus是0，那么node的waitStatus就会被置为SIGNAL，第二次再走到这里，就会用LockSupport的park方法把当前线程阻塞住
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    throw new InterruptedException();
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

/** Marker to indicate a node is waiting in shared mode */
 static final Node SHARED = new Node();
 /** Marker to indicate a node is waiting in exclusive mode */
 static final Node EXCLUSIVE = null;

private Node addWaiter(Node mode) {
        Node node = new Node(Thread.currentThread(), mode);
        // 尝试快速入队操作，因为大多数时候尾节点不为 null
        Node pred = tail;
        if (pred != null) {
            node.prev = pred;
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
    	//如果尾节点为空(也就是队列为空) 或者尝试CAS入队失败(由于并发原因)，进入enq方法
        enq(node);
        return node;
    }

private Node enq(final Node node) {
    	// 死循环+CAS保证所有节点都入队
        for (;;) {
            Node t = tail;
            // 如果队列为空 设置一个空节点作为 head
            if (t == null) { // Must initialize
                if (compareAndSetHead(new Node()))
                    tail = head;
            } else {
                //加入队尾
                node.prev = t;
                if (compareAndSetTail(t, node)) {
                    t.next = node;
                    return t;
                }
            }
        }
    }

private void setHeadAndPropagate(Node node, int propagate) {
    	//备份现在的 head
        Node h = head;  
    	//抢到锁的线程被唤醒 将这个节点设置为head
        setHead(node)
    	// propagate 一般都会大于0 或者存在可被唤醒的线程
        if (propagate > 0 || h == null || h.waitStatus < 0 ||
            (h = head) == null || h.waitStatus < 0) {
            Node s = node.next;
            // 只有一个节点 或者是共享模式 释放所有等待线程 各自尝试抢占锁
            if (s == null || s.isShared())
                doReleaseShared();
        }
    }

//线程已被 cancelled ，这种状态的节点将会被忽略，并移出队列
static final int CANCELLED =  1;
// 表示当前线程已被挂起，并且后继节点可以尝试抢占锁
static final int SIGNAL    = -1;
//线程正在等待某些条件
static final int CONDITION = -2;
//共享模式下 无条件所有等待线程尝试抢占锁
static final int PROPAGATE = -3;

// AQS类
public final boolean releaseShared(int arg) {
    	// arg 为固定值 1
    	// 如果计数器state 为0 返回true，前提是调用 countDown() 之前不能已经为0
        if (tryReleaseShared(arg)) {
            // 唤醒等待队列的线程
            doReleaseShared();
            return true;
        }
        return false;
    }

// CountDownLatch 重写的方法
protected boolean tryReleaseShared(int releases) {
            // Decrement count; signal when transition to zero
    		// 依然是循环+CAS配合 实现计数器减1
            for (;;) {
                int c = getState();
                if (c == 0)
                    return false;
                int nextc = c-1;
                if (compareAndSetState(c, nextc))
                    return nextc == 0;
            }
        }

/// AQS类
 private void doReleaseShared() {
        for (;;) {
            Node h = head;
            if (h != null && h != tail) {
                int ws = h.waitStatus;
                // 如果节点状态为SIGNAL，则他的next节点也可以尝试被唤醒
                if (ws == Node.SIGNAL) {
                    if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                        continue;            // loop to recheck cases
                    unparkSuccessor(h);
                }
                // 将节点状态设置为PROPAGATE，表示要向下传播，依次唤醒
                else if (ws == 0 &&
                         !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                    continue;                // loop on failed CAS
            }
            if (h == head)                   // loop if head changed
                break;
        }
    }

final CyclicBarrier cyclicBarrier = new CyclicBarrier(2, () -> doWork("C"));
final Thread ta = new Thread(() -> {
  doWork("A");
  try {
    cyclicBarrier.await();
  } catch (final InterruptedException | BrokenBarrierException e) {
    e.printStackTrace();
  }
});
final Thread tb = new Thread(() -> {
  doWork("B");
  try {
    cyclicBarrier.await();
  } catch (InterruptedException | BrokenBarrierException e) {
    e.printStackTrace();
  }
});

ta.start();
tb.start();

final Semaphore semaphore = new Semaphore(2);
Thread ta = new Thread(() -> {
  try {
    semaphore.acquire();
  } catch (InterruptedException e1) {
    e1.printStackTrace();
  }
  doWork("A");
  semaphore.release();
});
Thread tb = new Thread(() -> {
  try {
    semaphore.acquire();
  } catch (InterruptedException e1) {
    e1.printStackTrace();
  }
  doWork("B");
  semaphore.release();
});
Thread tc = new Thread(() -> {
  try {
    semaphore.acquire(2);
  } catch (InterruptedException e1) {
    e1.printStackTrace();
  }
  doWork("C");
});
ta.start();
tb.start();
tc.start();

ThreadPoolExecutor executor = new ThreadPoolExecutor(3, 3, 1, TimeUnit.MINUTES, new LinkedBlockingDeque<>());
Future<Boolean> aFuture = executor.submit(() -> {
  doWork("A");
  return true;
});
Future<Boolean> bFuture = executor.submit(() -> {
  doWork("B");
  return true;
});
executor.execute(() -> {
  try {
    aFuture.get();
    bFuture.get();
  } catch (InterruptedException | ExecutionException e1) {
    e1.printStackTrace();
  }
  doWork("C");
});

LinkedBlockingDeque<Integer> queue = new LinkedBlockingDeque<>(2);
Thread ta = new Thread(() -> {
  doWork("A");
  queue.add(1);
});
Thread tb = new Thread(() -> {
  doWork("B");
  queue.add(1);
});
Thread tc = new Thread(() -> {
  try {
    queue.take();
    queue.take();
  } catch (InterruptedException e) {
    e.printStackTrace();
  }
  doWork("C");
});
ta.start();
tb.start();
tc.start();