Semaphore&Future&动态代理(3)--分布式系统&中间件从入门到精通（七）

前面主要写了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);
    }

这时候动态代理就可以减去这种麻烦，动态代理可以动态生成具体委托类的代理实现对象，与静态代理不同的是，不需要单个委托一一实现的代理类，只需要为一类代理写个具体的实现类就行。