public class TryReentrantLock implements Runnable{static ReentrantLock lock=new ReentrantLock();static int i=0;@Overridepublic void run() {for(int j=0;j<10000;j++){lock.lock();try{i++;}finally {lock.unlock();}//重入锁可以反复进入，当然这种进入仅限于一个线程！因此可以如下：/*lock.lock(); lock.lock();try{i++;}finally {lock.unlock();lock.unlock();}*/}}public static void main(String[] args) throws InterruptedException {TryReentrantLock l=new TryReentrantLock();Thread t1=new Thread(l);Thread t2=new Thread(l);t1.start(); t2.start();t1.join(); t2.join();System.out.println(i);}
}

public class IntLock implements Runnable{public static ReentrantLock lock1=new ReentrantLock();public static ReentrantLock lock2=new ReentrantLock();int state;/*控制加锁顺序，便于产生死锁。*/public IntLock(int state){this.state=state;}@Overridepublic void run() {try{if(state==1){lock1.lockInterruptibly(); //设置可中断的锁try{Thread.sleep(500); //便于产生死锁}catch (InterruptedException e){e.printStackTrace();}lock2.lockInterruptibly();}else{lock2.lockInterruptibly();try{Thread.sleep(500);}catch (InterruptedException e){e.printStackTrace();}lock1.lockInterruptibly();}}catch (Exception e){e.printStackTrace();}finally {if(lock1.isHeldByCurrentThread()) lock1.unlock();if(lock2.isHeldByCurrentThread()) lock2.unlock();System.out.println(Thread.currentThread().getName()+" :quit!");}}public static void main(String[] args) throws InterruptedException {IntLock intLock1=new IntLock(1);IntLock intLock2=new IntLock(2);Thread t1=new Thread(intLock1);t1.setName("t1");Thread t2=new Thread(intLock2);t2.setName("t2");t1.start(); t2.start();Thread.sleep(1000);t2.interrupt();}
}

public class TimeLock implements Runnable{public static ReentrantLock lock=new ReentrantLock();@Overridepublic void run() {try{if(lock.tryLock(5, TimeUnit.SECONDS)){//注意返回布尔值.如果使用无参数的tryLock方法，// 当锁被占用时，线程会不等待，并返回false。Thread.sleep(6000);}else{System.out.println("Get lock failed!");}}catch (Exception e){e.printStackTrace();}finally {if (lock.isHeldByCurrentThread()) lock.unlock();}}public static void main(String[] args){TimeLock timeLock=new TimeLock();Thread t1=new Thread(timeLock);Thread t2=new Thread(timeLock);t1.start();t2.start();}
}

public ReentrantLock(boolean fair); //true表示公平锁

void await() throws InterruptedException //释放当前线程持有的锁，进入等待状态，当其他线程使用signal或signalAll()方法时继续执行。当线程被中断时会跳出等待。void awaitUninterruptibly();与await()方法相似，当中断时不会跳出等待。void signal();
void signalAll();

public class ReentrantCondition implements Runnable{static ReentrantLock lock=new ReentrantLock();static Condition condition=lock.newCondition();@Overridepublic void run() {try{lock.lock();System.out.println(Thread.currentThread().getName()+" is running fast!");condition.await();System.out.println(Thread.currentThread().getName()+" is going no.");}catch (InterruptedException e){e.printStackTrace();}finally {lock.unlock();}}public static void main(String[] args) throws InterruptedException {ReentrantCondition rc=new ReentrantCondition();Thread t=new Thread(rc,"King of Lock");t.start();Thread.sleep(2000);lock.lock(); //调用signal前先要获得锁
        condition.signal();lock.unlock(); //调用singal后要释放锁，以让给被唤醒的线程。
    }
}

public Semaphore(int permits); //permits指定同时能有几个线程访问同一资源。
public Semaphore(int permits,boolean fair) //fair指定是否采用公平锁

public void acquire()  //尝试获得一个准入许可，若无法获得，则线程会等待，直到有线程释放了一个许可，或者当前线程被中断
public void acquireUninterruptibly() //不响应中断
public void release() //释放一个许可

public CountDownLatch(int count) //count为需要完成几个线程上的任务，CountDownLatch上的线程才能继续执行。

public class CountDownLatchDemo implements Runnable{static final CountDownLatch latch=new CountDownLatch(10); //需要完成10个线程的任务，// CountDownLatch上的线程才能继续执行static final CountDownLatchDemo demo=new CountDownLatchDemo();@Overridepublic void run() {try{Thread.sleep(1000);System.out.println(Thread.currentThread().getName()+" :mission completed!");latch.countDown();//通知CountDownLatch一个任务已经完成。}catch (Exception e){e.printStackTrace();}}public static void main(String[] args) throws InterruptedException {ExecutorService ex= Executors.newFixedThreadPool(10);for(int i=0;i<10;i++){ex.submit(demo);}latch.await(); //设置要等待其他线程完成的那个线程System.out.println("Killed them all!");ex.shutdown();}
}

public CyclicBarrier(int parties,Runnable barrierAction) //barrierAction为计数完成后要执行的动作

public class CyclicBarrierDemo {public static class Soldier implements Runnable{private String name;private final CyclicBarrier barrier;Soldier(String name,CyclicBarrier barrier){this.name=name;this.barrier=barrier;}@Overridepublic void run() {try{barrier.await(); //进入等待状态，直到所有线程完成计数。doWork();        //所有线程完成一次await，继续执行。barrier.await(); //第二次await再次进入等待状态。}catch (Exception e){}}void doWork(){try{Thread.sleep(Math.abs(new Random().nextInt()%10000));}catch (Exception e){e.printStackTrace();}System.out.println("任务完成！");}}public static class FlyRun implements Runnable{boolean flag;int count;public FlyRun(boolean flag,int count){this.flag=flag;this.count=count;}@Overridepublic void run() {if (flag) System.out.println("队长："+count+" 个士兵完成任务！");else {System.out.println("队长："+count+" 个士兵集合完毕！");flag=true;}}}public static void main(String[] args){final int count=12;Thread[] soldiers=new Thread[count];boolean flag=false;CyclicBarrier barrier=new CyclicBarrier(count,new FlyRun(flag,count));//集合队伍System.out.println("集合队伍！");for(int j=0;j<count;j++){System.out.println("士兵"+j+"报道！");soldiers[j]=new Thread(new Soldier("士兵"+j,barrier));soldiers[j].start();}}
}

public class LockSupportDemo {public static Object instance=new Object();public static ChangThread t1=new ChangThread("t1");public static ChangThread t2=new ChangThread("t2");public static class ChangThread extends Thread{public ChangThread(String name){super.setName(name);}@Overridepublic void run(){synchronized(instance){System.out.println("in"+getName());LockSupport.park();}}}public static void main(String[] args) throws InterruptedException {t1.start();Thread.sleep(100);t2.start();LockSupport.unpark(t1); //即使unpark()发生在park前，程序也能正常执行。
        LockSupport.unpark(t2);t1.join();t2.join();}
}