前面主要写了countDownLatch和cyclicBarrier的代码实例，前者是在主线程通过await等待，当所有子线程调用countDown则释放等待，cyclicBarrier则是主线程和子线程都await，所以构造参数里的值会比实际任务数量+1，并且是所有的线程到达await之后，则一起运行。
Java中间件(2)--分布式系统&中间件从入门到精通（六）
Semaphore是用于管理信号量，构造函数可以传递参数，这个就是管理的数量，控制总的并发数量。执行业务之前通过acquire()方法获取信号许可，业务执行完成之后执行release()方法归还信号许可，每次acquire()返回成功后，信号的数量就会减少1来就控制并发量，当其他线程没有可以用的信号，这时候就会发生阻塞，等待release来归还信号，释放阻塞线程。如果semaphore管理的信号只有1个的时候，则会退化成互斥锁，如果有多个信号，则主要控制并发数。其实通过控制线程数也可以通过控制并发树，与前者相比，通过semaphore来控制并发数可以控制的更细颗粒度，因为真正被控制的最大并发代码放到acquire和release之间，值得注意的是，release调用时候必须放在finally里面执行，防止业务发生异常。
Exchanger顾名思义就是交换机，当一个不同的线程运行里面的exchange，会等待着另一个线程页运行exchange，然后把双方的数据交换，交换之后，两个线程继续执行自身的代码。
int max = 100; ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2, 2, 60L, TimeUnit.SECONDS, new LinkedBlockingQueue<>(max)); final Exchanger<List<Integer>> exchanger = new Exchanger<>(); for (int i = 0; i < max; i++) { int finalI = i; threadPoolExecutor.execute(() -> { if (finalI == 1) { List<Integer> list = new ArrayList<>(); list.add(1); try { list = exchanger.exchange(list); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("1里面：" + list); } if (finalI == 2) { List<Integer> list = new ArrayList<>(); list.add(2); try { list = exchanger.exchange(list); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("2里面：" + list); } }); } threadPoolExecutor.shutdown();
Future和FutureTask
Future是一个接口，futureTask是一个具体的实现类，正常写代码的时候，可以用一个方法获取数据，当数据返回的时候，下面的代码继续执行但如果返回的数据跟下面的值没关系，可以分开运行怎么办呢，这时候可以用future，可以用线程池返回一个future实现，然后用get获取里面的值，也可以设置获取值的过期时间，等待时间内获取值，而不是一直等待下去。
FutureTask是future接口的实现类，帮助实现了具体的任务执行以及future接口中的get关联，futureTask除了帮助ThreadPoolExecutor很好的实现对future支持外，也可以实现支持future的任务调度。
int max = 100; ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(10, 10, 60L, TimeUnit.SECONDS, new LinkedBlockingQueue<>(max)); for (int i = 0; i < max; i++) { Future<String> stringFuture = threadPoolExecutor.submit(new Callable<String>() { @Override public String call() { return "名字：" + Thread.currentThread().getName(); } }); try { String result = stringFuture.get(3000, TimeUnit.SECONDS); System.out.println("成功返回:" + result); } catch (Exception e) { } } threadPoolExecutor.shutdown();
并发容器
Jdk中有着一些线程不安全的容器，也有一些线程安全的容器。并发容器是线程安全容器的一种，但是这不仅仅追求线程安全，还要提高高并发，加锁互斥也能实现线程安全，但效率低下，可以理解为串行运行。但并发容器就是尽量不用锁，代表就是copyonWrite和concurrent开头的几个容器。CopyonWrite就是读多写少，写不冲突的场景可以用，比如ReentrantLock的读写锁。
静态代理&动态代理
静态代理方式就是每个代理对象都需要写一个代理类，这种方法代码想对臃肿，下面我们写一个calculator接口，然后具体实现接口calculatorImpl和一个代理类calculatorProxy，我们在代理类用真实调用了实现类的add方法，这种方法缺点就是当对多个类进行代理的时候，并且功能是一致的，这时候需要给每个类都写一个代理类。
public interface Calculator { int add(int a, int b); } public class CalculatorImpl implements Calculator { @Override public int add(int a, int b) { return a + b; } } public class CalculatorProxy implements Calculator{ @Autowired private Calculator calculator; CalculatorProxy(Calculator calculator){ this.calculator = calculator; } @Override public int add(int a, int b) { int result = calculator.add(a,b); return result; } } public class LogHandler implements InvocationHandler { Object obj; LogHandler(Object obj){ this.obj = obj; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { this.doBefore(); //调用代理 Object object = method.invoke(obj, args); this.doAfter(); return object; } private void doAfter() { System.out.println("do this after"); } private void doBefore() { System.out.println("do this before"); } } public static void main(String[] args) { Calculator calculator = new CalculatorImpl(); LogHandler logHandler = new LogHandler(calculator); Calculator proxyCalculator = (Calculator)Proxy.newProxyInstance(calculator.getClass().getClassLoader(), calculator.getClass().getInterfaces(), logHandler); Object object = proxyCalculator.add(1, 1); System.out.println("返回:" + object); }
这时候动态代理就可以减去这种麻烦，动态代理可以动态生成具体委托类的代理实现对象，与静态代理不同的是，不需要单个委托一一实现的代理类，只需要为一类代理写个具体的实现类就行。
