Java current并发包超详细分析

public class Demo01 {

     //public static Map<String,String> maps = new HashMap<String, String>();

     //public static Map<String,String> maps = new Hashtable<String, String>();

     public static Map<String,String> maps = new ConcurrentHashMap<String, String>();

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

         Runnable task = new Temp();

         Thread t1 = new Thread(task, "A线程" );

         Thread t2 = new Thread(task, "B线程" );

         t1.start();

         t2.start();

         // 保证t1和t2先执行完

         t1.join();

         t2.join();

         System.out.println( "最终集合长度：" +maps.size());

     }

}

class Temp implements Runnable{

     @Override

     public void run() {

         for ( int i = 0 ; i < 500000 ; i++) {

  Demo01.maps.put(Thread.currentThread().getName()+i,Thread.currentThread().getName()+i);

         }

     }

}

// 创建CountDownLatch

CountDownLatch cdl = new CountDownLatch( 1 );

cdl.await() // 让出cpu，使当前线程等待

cdl.CountDown() // 计数器减1，只有当计数器为零时才会唤醒被await的线程

public class Demo02 {

     public static void main(String[] args) {

         CountDownLatch count = new CountDownLatch( 1 );

         new ThreadA(count).start();

         new ThreadB(count).start();

     }

}

class ThreadA extends Thread{

     private CountDownLatch count;

     public ThreadA(CountDownLatch count) {

         this .count = count;

     }

     @Override

     public void run() {

         System.out.println( "A" );

         // 使当前线程等待  等待打印B之后宰继续执行打印A

         try {

             count.await();

         } catch (InterruptedException e) {

             throw new RuntimeException(e);

         }

         System.out.println( "C" );

     }

}

class ThreadB extends Thread{

     private CountDownLatch count;

     public ThreadB(CountDownLatch count) {

         this .count = count;

     }

     @Override

     public void run() {

         System.out.println( "B" );

         // 当前线程执行完后倒计数减一

         count.countDown();

     }

}

// 六条线程：五个员工进入会议室、一个开会

public class CyclicBarrierDemo {

     public static void main(String[] args) {

         // 创建循环屏障

         CyclicBarrier cb = new CyclicBarrier( 5 , new Metting());

         for ( int i = 1 ; i <= 4 ; i++) {

             new Employee(i+ "号员工" ,cb).start();

         }

     }

}

class Employee extends Thread{

     private CyclicBarrier cb;

     public Employee(String s, CyclicBarrier cb) {

         super (s);

         this .cb = cb;

     }

     @Override

     public void run() {

         System.out.println(Thread.currentThread().getName()+ "进入会议室" );

         try {

             Thread.sleep( 1000 );

             cb.await();

         } catch (Exception e) {

             e.printStackTrace();

         }

     }

}

class Metting implements Runnable{

     @Override

     public void run() {

         System.out.println(Thread.currentThread().getName()+ "组织会议,会议开始" );

     }

}

CyclicBarrier cb = new CyclicBarrier( 5 , new Metting());

public Semaphore( int permits) // permits为允许执行的线程数

public Semaphore( int permits, boolean fair)

     // fair为true表示公平锁，等待时间最长的线程将在下次进入 反之是不公平锁

public void acquire()  // 表示获得许可

public void release()  // 表示释放许可

public class SemaphoreDemo {

     public static void main(String[] args) {

         // 创建任务

         Service service = new Service();

         for ( int i = 1 ; i <= 5 ; i++) {

             new MyThread(i+ "号线程" ,service).start();

         }

     }

}

// 线程类

class MyThread extends Thread{

     private Service service;

     public MyThread(String name,Service service){

         super (name);

         this .service = service;

     }

     @Override

     public void run() {

         try {

             service.testMethod();

         } catch (Exception e) {

             throw new RuntimeException(e);

         }

     }

}

// 抽离业务代码

class Service{

     // 创建Semaphore对象 并指定线程数

     private Semaphore sp = new Semaphore( 2 );

     public void testMethod() throws Exception {

         // 获取许可

         sp.acquire();

         System.out.println(Thread.currentThread().getName()+ "进入  时间：" +System.currentTimeMillis());

         Thread.sleep( 200 );

         System.out.println(Thread.currentThread().getName()+ "执行成功" );

         System.out.println(Thread.currentThread().getName()+ "离开  时间：" +System.currentTimeMillis());

         // 释放许可

         sp.release();

     }

}

public class ExchangerDemo {

     public static void main(String[] args) {

         // 创建交换者

         Exchanger<String> exchanger = new Exchanger<>();

         // 创建两条线程进行交换数据

         new ThreadN( "线程N" ,exchanger).start();

         new ThreadP( "线程P" ,exchanger).start();

     }

}

class ThreadN extends Thread{

     private Exchanger<String> exchanger;

     public ThreadN(String name,Exchanger<String> exchanger) {

         super (name);

         this .exchanger = exchanger;

     }

     @Override

     public void run() {

         System.out.println(Thread.currentThread().getName()+ "给线程P：" + "我是线程N" );

         try {

             String exchange = exchanger.exchange( "我是线程N" );

             System.out.println( "线程N拿到数据：" +exchange);

         } catch (InterruptedException e) {

             throw new RuntimeException(e);

         }

     }

}

class ThreadP extends Thread{

     private Exchanger<String> exchanger;

     public ThreadP(String name,Exchanger<String> exchanger) {

         super (name);

         this .exchanger = exchanger;

     }

     @Override

     public void run() {

         System.out.println(Thread.currentThread().getName()+ "给线程N：" + "我是线程P" );

         try {

             String exchange = exchanger.exchange( "我是线程P" );

             System.out.println( "线程P拿到数据：" +exchange);

         } catch (InterruptedException e) {

             throw new RuntimeException(e);

         }

     }

}

public V exchange(V x, long timeout, TimeUnit unit)

     // timeout等待的时间数值  unit时间单位

     // 示例：只等待五秒

exchanger.exchange( "111" , "5000" , TimeUnit.SECONDS)