//将空闲连接添加到队列
void	add(final	T	bagEntry){
    //加⼊共享队列
    sharedList.add(bagEntry);
    //如果有等待连接的线程，
    //则通过handoffQueue直接分配给等待的线程
    while(waiters.get()	>	0
    &&	bagEntry.getState()	==	STATE_NOT_IN_USE	
    &&	!handoffQueue.offer(bagEntry))	{
        yield();
    }
}

//限流器流速：2个请求/秒
RateLimiter limiter = RateLimiter.create(2.0);
//执⾏任务的线程池
ExecutorService es = Executors.newFixedThreadPool(1);
//记录上⼀次执⾏时间
prev = System.nanoTime();
//测试执⾏20次
for (int i = 0; i < 20; i++) {
    //限流器限流
    limiter.acquire();
    //提交任务异步执⾏
    es.execute(() -> {
        long cur = System.nanoTime();
        //打印时间间隔：毫秒
        System.out.println(
                (cur - prev) / 1000_000);
        prev = cur;
    });
}    

class SimpleLimiter {
    //当前令牌桶中的令牌数量
    long storedPermits = 0;
    //令牌桶的容量
    long maxPermits = 3;
    //下⼀令牌产⽣时间
    long next = System.nanoTime();
    //发放令牌间隔：纳秒
    long interval = 1000_000_000;

    //请求时间在下⼀令牌产⽣时间之后,则
    //	1.重新计算令牌桶中的令牌数
    //	2.将下⼀个令牌发放时间重置为当前时间
    void resync(long now) {
        if (now > next) {
            //新产⽣的令牌数
            long newPermits = (now - next) / interval;
            //新令牌增加到令牌桶
            storedPermits = min(maxPermits, storedPermits + newPermits);
            //将下⼀个令牌发放时间重置为当前时间
            next = now;
        }
    }

    //预占令牌，返回能够获取令牌的时间
    synchronized long reserve(long now) {
        resync(now);
        //能够获取令牌的时间
        long at = next;
        //令牌桶中能提供的令牌
        long fb = min(1, storedPermits);
        //令牌净需求：⾸先减掉令牌桶中的令牌
        long nr = 1 - fb;
        //重新计算下⼀令牌产⽣时间
        next = next + nr * interval;
        //重新计算令牌桶中的令牌
        this.storedPermits -= fb;
        return at;
    }

    //申请令牌
    void acquire() {
        //申请令牌时的时间
        long now = System.nanoTime();
        //预占令牌
        long at = reserve(now);
        long waitTime = max(at - now, 0);
        //按照条件等待
        if (waitTime > 0) {
            try {
                TimeUnit.NANOSECONDS.sleep(waitTime);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

//任务队列
BlockingQueue<Task> bq = new LinkedBlockingQueue<>(2000);
//启动5个消费者线程
//执⾏批量任务
void start () {
    ExecutorService es = xecutors
            .newFixedThreadPool(5);
    for (int i = 0; i < 5; i++) {
        es.execute(() -> {
            try {
                while (true) {
                    //获取批量任务
                    List<Task> ts = pollTasks(); //执⾏批量任务
                    execTasks(ts);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        });
    }
}
//从任务队列中获取批量任务
List<Task> pollTasks ()	
		throws InterruptedException {
    List<Task> ts = new LinkedList<>();
    //阻塞式获取⼀条任务
    Task t = bq.take();
    while (t != null) {
        ts.add(t);
        //⾮阻塞式获取⼀条任务
        t = bq.poll();
    }
    return ts;
}
//批量执⾏任务
execTasks(List < Task > ts) {
    //省略具体代码⽆数
}

class Logger {
    //任务队列
    final BlockingQueue<LogMsg> bq
            = new BlockingQueue<>();
    //flush批量
    static final int batchSize = 500;
    //只需要⼀个线程写⽇志
    ExecutorService es =
            Executors.newFixedThreadPool(1);

    //启动写⽇志线程
    void start() {
        File file = File.createTempFile("foo", ".log");
        final FileWriter writer =
                new FileWriter(file);
        this.es.execute(() -> {
            try {
                //未刷盘⽇志数量
                int curIdx = 0;
                long preFT = System.currentTimeMillis();
                while (true) {
                    LogMsg log = bq.poll(
                            5, TimeUnit.SECONDS);
                    //写⽇志
                    if (log != null) {
                        writer.write(log.toString());
                        ++curIdx;
                    }
                    //如果不存在未刷盘数据，则⽆需刷盘
                    if (curIdx <= 0) {
                        continue;
                    }
                    //根据规则刷盘
                    if (log != null && log.level == LEVEL.ERROR ||
                            curIdx == batchSize ||
                            System.currentTimeMillis() - preFT > 5000) {
                        writer.flush();
                        curIdx = 0;
                        preFT = System.currentTimeMillis();
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    writer.flush();
                    writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        });
    }

    //写INFO级别⽇志
    void info(String msg) {
        bq.put(new LogMsg(
                LEVEL.INFO, msg));
    }

    //写ERROR级别⽇志
    void error(String msg) {
        bq.put(new LogMsg(
                LEVEL.ERROR, msg));
    }
}

//⽇志级别
enum LEVEL {
    INFO, ERROR
}

class LogMsg {
    LEVEL level;
    String msg;

    //省略构造函数实现
    LogMsg(LEVEL lvl, String msg) {
    }

    //省略toString()实现
    String toString() {
    }
}

//L1、L2两阶段任务共用一个线程池
ExecutorService es = Executors.
  newFixedThreadPool(2);
//L1阶段的闭锁    
CountDownLatch l1=new CountDownLatch(2);
for (int i=0; i<2; i++){
  System.out.println("L1");
  //执行L1阶段任务
  es.execute(()->{
    //L2阶段的闭锁 
    CountDownLatch l2=new CountDownLatch(2);
    //执行L2阶段子任务
    for (int j=0; j<2; j++){
      es.execute(()->{
        System.out.println("L2");
        l2.countDown();
      });
    }
    //等待L2阶段任务执行完
    l2.await();
    l1.countDown();
  });
}
//等着L1阶段任务执行完
l1.await();
System.out.println("end");