Java 并发（JUC 包-02）

>JUC ？就是Java API 中这三个包的简称：

>concurrent 包

1.线程池

对于N个任务，可以来一个任务就开辟一个线程。而线程池的思想是，用一个线程池去处理这N个任务。

使用线程池一般步骤：

使用Executor类的静态方法创建ExecutorService对象，该对象就代表一个线程池。
使用这个线程池的execute 或submit 方法来提交一个任务，而这个任务就是一个线程。
要关闭一个线程池，可以使用ExecutorService对象的shutdown 方法。

public class TestThreadPool {public static void main(String[] args) {// 固定大小线程池Executor threadPool = Executors.newFixedThreadPool(4);// 拓展线程池 根据线程使用率进行清空Executor threadPool2 = Executors.newCachedThreadPool();// 单线程Executor threadPool3 = Executors.newSingleThreadExecutor();Random r = new Random();Runnable target = new Runnable() {@Overridepublic void run() {for (int i = 0; i < 10; i++) {System.out.println(Thread.currentThread().getName() + "第" + i + "个任务");try {Thread.sleep(r.nextInt(500));} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}};for (int i = 0; i < 10; i++) {// new Thread(target).start();threadPool2.execute(target);}}
}

2.future

前面学习的“Future提前完成任务模式”。其实实现了一种异步计算结果，主程序不受调用程序处理时间长短而控制，提前返回控制权。而这里JUC提供的Callable和Future就是完成了这一功能。

Callable类似于一个增强的Runnable 接口，与之不同的是Callable提供了一个call() 方法来执行线程代码，call() 方法可以有返回值，也可以声明式地抛出异常。

为什么要使用Future？多线程的返回值问题

使用流派:

继承Callable接口，实现call() 方法，这个call() 方法不仅是线程的执行体，也可以有返回值。
使用FutureTask 对象包装Callable 对象，因为FutureTask实现了Runnable 接口，可以作为Thread 的执行载体。FutureTask封装了call() 方法的返回值。
使用FutureTask 对象作为Thread 载体创建线程。
使用FutureTask 对象的get() 方法获得线程执行结果。

public class TestCallable {public static void main(String[] args) throws Exception {TestCallable tc = new TestCallable();tc.go();}private void go() throws Exception {// 一个小注意点：内部类也是成员，非静态的情况不能直接在main中new，成员方法中可以MyThread mt = new MyThread();FutureTask<Integer> ft = new FutureTask<Integer>(mt);new Thread(ft).start();System.out.println("我想干点别的，等待结果来了之后我拿结果");// Integer i = ft.get();//直接写get(),任务结束后取值Integer j = ft.get(1, TimeUnit.SECONDS);// 拿结果的最长等待时间，如果超时等不到就报错。// Exception in thread "main"// java.util.concurrent.TimeoutExceptionSystem.out.println(j);}/*** 增强版线程： 1、可以有返回值 2、可以throws 异常*/class MyThread implements Callable<Integer> {@Overridepublic Integer call() throws Exception {Thread.sleep(2000);return 1;}}
}

如何在线程池中使用Callable 和 Future？

线程池中，也可以使用Callable和Future，用法很简单。只是不必使用Future 的实现类FutureTask ，因为线程池可以直接提交一个Callable任务，而不像使用Thread 必须有一个Runnable 载体。

使用流派:

创建线程池、Callable 对象。
使用线程池 submit() 提交Callable 对象。返回Future对象。
使用Future对象的 get() 方法，获得返回值。

public class TestCallableThreadPool {public static void main(String[] args) {TestCallableThreadPool t = new TestCallableThreadPool();t.go();}private void go() {ExecutorService threadPool = Executors.newCachedThreadPool();Future<String> future = threadPool.submit(new MyThread());try {String string = future.get();System.out.println(string);} catch (InterruptedException | ExecutionException e) {// TODO Auto-generated catch blocke.printStackTrace();}}class MyThread implements Callable<String> {@Overridepublic String call() throws Exception {Thread.sleep(2000);return "hello world";}}
}

3.同步容器、并发容器

>3.1

传统的容器比如线程不安全的ArrayList：

线程安全的Vector（区别就是加了锁），即使需要线程安全的容器，我们也不使用Vector，使用工具类Collections转换为线程安全的类：

典型的代理模式实现，对ArrayList 的方法进行包装，最终干活的还是ArrayList：

>3.2迭代时删除问题

首先，不要在 foreach 循环里进行元素的 remove/add 操作

public class TestTh {public static void main(String[] args) {List<String> list = new ArrayList<>();list = Collections.synchronizedList(list);for (int i = 0; i < 100; i++) {list.add(String.valueOf(i));}for (String string : list) {if (string.equals("30")) {System.out.println(string);list.remove(string);}}}}

会报错：

并发容器CopyOnWriteArrayList，解决遍历时修改的问题，满足了读一致性，

注意与同步容器（解决线程安全问题）区分：

public class Test {public static void main(String[] args) {Test t = new Test();t.go();}private void go() {V v = new V();new Thread(new Runnable() {@Overridepublic void run() {v.show();}}).start();new Thread(new Runnable() {@Overridepublic void run() {v.modify();}}).start();}class V {// 两个线程同时操作一个线程（一个线程监测，一个修改就报错），也有问题// private List<Integer> list = new ArrayList<>();// 并发容器，与前面的同步容器进行区分private List<Integer> list = new CopyOnWriteArrayList<>();public V() {for (int i = 0; i < 100; i++) {list.add(i);}// list=Collections.synchronizedList(list);}public void show() {for (int i : list) {System.out.println(i);try {Thread.sleep(20);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}public void modify() {for (int i = 200; i < 300; i++) {list.add(i);}try {Thread.sleep(20);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}
}

>3.3使用并发容器ConcurrentHashMap设计一个缓存：