限流和对象池简单实现

限流和自定义对象池

限流是当资源有限的时候，限制客户端对资源访问的一种思路。比如当访问量过大的时候，限制用户访问并给予用户友好的反馈。在比如我们常用的线程池就是一种限池，服务器不可能无限的创建线程，因为就有了线程池，给予一个合适的线程数量让客户端去使用，当客户端访问量过大的时候去让客户端等待或者抛出异常等等操作。

实现思路

我们的思路是对需要访问的对象进行包装，外面的客户端要使用使用这个资源需要通过包装对象才行。我们在创建这个包装对象的时候需要指定多少个客户端 可以同时访问包装对象里面的资源。在访问这个对象里面的资源的时候要先进行判断，第一步的判断就像我们这个包装对象的卫士一样。控制着访问量。而这个卫士我们使用的方式就是使用java中的信息量。关于信号量的基本概念请参考我的另一篇博客 https://blog.csdn.net/u011296165/article/details/89944540

代码实现

以下代码是基于jdk1.8所做的开发。基中使用了范型。 范型T是请求参数的类型，范型R是响应参数的类型。这是基于范型的基本思路类型参数化做的。 其中的Function是1.8的新特性，是代表了有参数有返回值的方法。

package com.bdf.blog.thread.Semaphore;

        import java.util.List;
        import java.util.Vector;
        import java.util.concurrent.LinkedBlockingDeque;
        import java.util.concurrent.Semaphore;
        import java.util.concurrent.ThreadPoolExecutor;
        import java.util.concurrent.TimeUnit;
        import java.util.function.Function;

public class ObjPool<T,R> {
    final List<T> pool;

    final Semaphore sem;

    public ObjPool(int size, T t) {
        pool = new Vector<T>(){};
        for (int i=0;i<size;i++){
            pool.add(t);
        }
        sem = new Semaphore(size);
    }

    // 利用对象池中的对象调用 func
    R exec(Function<T,R> func) throws InterruptedException {
        T t = null;
        sem.acquire();
        try{
            t = pool.remove(0);
            return func.apply(t);
        }finally {
            pool.add(t);
            sem.release();
        }
    }

    public static void main(String[] args) throws Exception {
        //目标：测试信息量如果进入线程为5个的时候 会不会可以进入新的线程。

        //初始化对象线程池，线程池大小为5
        ObjPool<String, String> pool= new ObjPool<String, String>(5, "田帅");
        // 初始化执行线程池 线程执行大小为10
        ThreadPoolExecutor executor = new ThreadPoolExecutor(10,20,200, TimeUnit.MICROSECONDS,new LinkedBlockingDeque<>());
        // 此处是调用20个线程进入信息量
        for (int i = 0; i < 20; i++) {
            executor.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        String exec = pool.exec(t -> {
                            System.out.println(t);
                            try {
                                System.out.printf("线程名为："+ Thread.currentThread().getName());
                                Thread.sleep(10000);
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                            return t.toString();
                        });
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }

    }

}