public class ReentrantLockTest {
    private final ReentrantLock lock = new ReentrantLock();
    // ...

    public void doSomething() {
        lock.lock();  // block until condition holds
        try {
            // ... method body
        } finally {
            lock.unlock();
        }
    }
}

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class ProxyDemo {
    public static void main(String[] args) {

        //1.创建委托对象
        AbsSubject real = new RealSub();
        
        //2.创建调用处理器对象
        ProxyHandler handler = new ProxyHandler(real);
        
        //3.动态生成代理对象
        AbsSubject proxySub = (AbsSubject)Proxy.newProxyInstance(real.getClass().getClassLoader(),
                real.getClass().getInterfaces(), handler);
        
        //4.通过代理对象调用方法
        proxySub.doJob();
        proxySub.sum(3,  9);
        int m = proxySub.multiply(3, 7);
        System.out.println("multiply result is:"+m);
    }
}

//被代理类的接口
interface AbsSubject {
    void doJob();
    void sum(int a, int b);
    int multiply(int a, int b);
}

//实际的被代理类
class RealSub implements AbsSubject {

    @Override
    public void doJob() {
        // TODO Auto-generated method stub
        System.out.println("i am doing something");
    }

    @Override
    public void sum(int a, int b) {
        System.out.println(a+" + "+b+" = "+(a+b));
    }

    @Override
    public int multiply(int a, int b) {
        // TODO Auto-generated method stub
        System.out.println(a+" * "+ b);
        return a*b;
    }
    
}

//动态代理的内部实现,调用处理器类，即实现 InvocationHandler 接口
//这个类的目的是指定运行时将生成的代理类需要完成的具体任务（包括Preprocess和Postprocess）
//即代理类调用任何方法都会经过这个调用处理器类
class ProxyHandler implements InvocationHandler {
    private Object realSub;
    
    public ProxyHandler(Object object) {
        realSub = object;
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("before");
        Object res = method.invoke(realSub, args);
        System.out.println("after");
        return res;
    }   
}

package com.ziggle.fan.service;

import com.google.common.util.concurrent.RateLimiter;
import io.lettuce.core.RedisCommandTimeoutException;
import io.lettuce.core.RedisConnectionException;
import lombok.extern.slf4j.Slf4j;
import org.springframework.dao.QueryTimeoutException;
import org.springframework.data.redis.connection.Message;
import org.springframework.data.redis.connection.MessageListener;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * redis 消息订阅
 *
 * @author: wp
 * @date: 2019-03-13 14:31
 */

@Slf4j
@Service
public class RedisMessageSubscriber implements MessageListener {

    private final StringRedisTemplate stringRedisTemplate;
    private final RateLimiter rateLimiter;

    public RedisMessageSubscriber(StringRedisTemplate stringRedisTemplate) {
        this.stringRedisTemplate = stringRedisTemplate;
        this.rateLimiter = RateLimiter.create(1);
    }

    @Override
    public void onMessage(Message message, byte[] pattern) {
        log.info("Received >> " + message + ", " + Thread.currentThread().getName());
    }

    private ExecutorService executorService = Executors.newSingleThreadExecutor(r -> {
        Thread thread = new Thread(r);
        thread.setName("insert-contact-th");
        thread.setDaemon(true);
        return thread;
    });
    private AtomicInteger flag = new AtomicInteger(0);

    @PreDestroy
    private void destroy() {
        Runtime.getRuntime().addShutdownHook(new Thread() {
            @Override
            public void run() {
                flag.getAndAdd(1);
            }
        });
        if (!executorService.isShutdown()) {
            executorService.shutdown();
        }
    }

//    @PostConstruct
    public void init() {
        RateLimiter errorRate = RateLimiter.create(1);
        executorService
                .submit(() -> {
                    for (; ; ) {
                        if (flag.get() != 0) {
                            break;
                        }
                        try {
                            // todo bug
                            String key = stringRedisTemplate.opsForList().leftPop("key", 3, TimeUnit.SECONDS);

                            if (key != null) {
                                log.warn(key);
                                rateLimiter.acquire();
                            }
                            log.info("nothing.... ");
                        } catch (Exception e) {
                            errorRate.acquire();
                            if (!(e instanceof RedisCommandTimeoutException || e instanceof QueryTimeoutException)) {
                                log.error(e.getMessage(), e);
                            } else {
                                //ignore
                            }
                        }
                    }
                });
    }
}