java并发2

7.x JDK多任务执行框架

8.x Concurrent.util工具类详细讲解和使用
CyclicBarrier使用：
假设有只有一个场景：每个线程代表一个跑步运动员，当运动员都准备好后，才一起出发，只要有一个人没准备好，大家都等待。示例：
CountDownLacth使用：
他经常用于监听某些初始化操作，等初始化执行完毕后，通知主线程继续工作。

public class UseCountDownLacth {
    public static void main(String[] args) {
        final CountDownLatch countDownLatch = new CountDownLatch(2);

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("进入线程t1");
                    countDownLatch.await();
                    System.out.println("线程t1.....");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("进入线程t2");
                    Thread.sleep(3000);
                    countDownLatch.countDown();
                    System.out.println("线程t2OK.....");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("进入线程t3");
                    Thread.sleep(3000);
                    countDownLatch.countDown();
                    System.out.println("线程t3OK.....");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        t1.start();
        t2.start();
        t3.start();
    }
}

Callable和Future使用 Future模式非常适合在处理很耗时很长的业务逻辑时进行使用，可以有效的减小系统的响应时间，提高系统的吞吐量。

public class UseFuture implements Callable<String> {
    private String para;
    public UseFuture(String para){
        this.para = para;
    }



    @Override
    public String call() throws Exception {
       Thread.sleep(3000);
       String result = this.para + "处理完成";
       return result;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        String queryStr = "query";
        FutureTask<String> future = new FutureTask<String>(new UseFuture(queryStr));
        ExecutorService executor = Executors.newFixedThreadPool(1);
        Future f = executor.submit(future);
        System.out.printf("请求完毕");

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("数据："+future.get());
    }
}

9.x （重入锁、读写锁使用）锁的高级深化