并发包下一些并发类

并发包下一些并发类

    引言：JDK1.5的并发包不仅仅提供了前文所说的线程池框架，还提供了一系列并发类，来便于我们编写高并发代码，本文我们来一一介绍。

    一、CountDownLatch类

    代码如下：

package com.example.first;

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

public class UseCountDown {
    public static void main(String args[]) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(2);
        Runnable runnable1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("线程1来了，await阻塞");
                try {
                    countDownLatch.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("阻塞结束，开始执行");
            }
        };
        Runnable runnable2 = new Runnable() {
            @Override
            public void run() {
                System.out.println("线程2来了");
                countDownLatch.countDown();
            }
        };
        Runnable runnable3 = new Runnable() {
            @Override
            public void run() {
                System.out.println("线程3来了");
                countDownLatch.countDown();
            }
        };
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(5);
        fixedThreadPool.execute(runnable1);
        fixedThreadPool.execute(runnable2);
        fixedThreadPool.execute(runnable3);
        fixedThreadPool.shutdown();
    }
}

    功能主要是提供了两个方法，一个是await()，用于阻塞当前线程，一个是countDown方法，用于改变CountDownLatch对象的状态。

    在CountDownLatch对象初始化的时候，需要在构造函数下加上一个整形的变量i，而await方法就会阻塞线程，只有当其他线程，执行了i次countDown方法，才能将被await阻塞的方法给重新激活。

    使用方式是十分的简单，使用场景主要在监听其他线程的初始化操作，当初始化完毕之后，便会提醒主线程开始运行。

    二、CyclicBarrier类

    代码如下：

package com.example.first;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class UseBarrier {
    public static void main(String args[]) throws InterruptedException {
 //       CountDownLatch countDownLatch = new CountDownLatch(2);
        CyclicBarrier cyclicBarrier = new CyclicBarrier(4);
        Runnable runnable1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("线程1准备好了");
                try {
                    cyclicBarrier.await();
                } catch (Exception e) {
                    e.printStackTrace();
                }
                System.out.println("阻塞结束，线程1开始执行");
            }
        };
        Runnable runnable2 = new Runnable() {
            @Override
            public void run() {
                System.out.println("线程2准备好了");
                try {
                    cyclicBarrier.await();
                } catch (Exception e) {
                    e.printStackTrace();
                }
                System.out.println("阻塞结束，线程2开始执行");
            }
        };
        Runnable runnable3 = new Runnable() {
            @Override
            public void run() {
                System.out.println("线程3准备好了");
                try {
                    cyclicBarrier.await();
                } catch (Exception e) {
                    e.printStackTrace();
                }
                System.out.println("阻塞结束，线程3开始执行");
            }
        };
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(5);
        fixedThreadPool.execute(runnable1);
        fixedThreadPool.execute(runnable2);
        fixedThreadPool.execute(runnable3);
        fixedThreadPool.shutdown();
    }
}

    特地去查了一下Barrier是什么意思，大概意思就是栅栏的意思，十分形象。实例化的方式和CountDown很像，都是有一个整数为参数的构造函数，也提供了await方法用于阻塞当前线程，激活线程的时机是当await的数量到达了构造参数中整数的值时。

    十分贴切他的意思--栅栏，只有当线程都到齐了，才能各就各位起跑。

    三、Future和FutureTask类

    代码如下：

package com.example;

import java.util.concurrent.*;

public class UseFuture {
    public static void main(String args[]) throws Exception {
        Callable<String> callable = new Callable<String>() {
            @Override
            public String call() throws Exception {
                Thread.sleep(3000);
                return "future开始！";
            }
        };
        FutureTask<String> futureTask = new FutureTask<String>(callable);
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(5);
        fixedThreadPool.submit(futureTask);
        System.out.println(futureTask.get());
        fixedThreadPool.shutdown();
    }
}

    实现方式，在很早之前写过，但是忘了大概。核心就是要使用Callable接口，重写里面的call方法，call方法有返回值，返回类型为Callable的泛型对象，将Callable出来的对象传入FutureTask的构造方法，再将FutureTask对象传给线程池的submit方法。

    submit和execute在大多数情况下无异，但是submit能够传入callable参数，返回Future参数，值得一说的是，FutureTask实现了Callable接口和Future。最后，当主线程调用了FutureTask的get()方法，便会等待FutureTask任务线程执行，返回call方法的值。这是JDK对Future模式的一种实现。