分布式锁

public class MemCacheLock {

	private MemCachedClient client;

	public MemCacheLock(MemCachedClient client) {
		this.client = client;
	}

	/**
	 * 通过 add(lockKey, token) 获取锁
	 *
	 * @param lockKey 上锁的 key
	 * @param retry 重试次数
	 * @param expireSec 过期时间，单位秒
	 * @param token key 对应的 value, 删除时比对避免释放其他客户端的锁
	 * @return
	 */
	public boolean acquire(String lockKey, int retry, int expireSec, String token) {
		// anyMatch 迭代 retry + 1 次，直到成功获取锁
		return IntStream.rangeClosed(0, retry).anyMatch((i) -> {
			// 第一次获取锁不等待，随后的重试等待 100 ms
			try {
				TimeUnit.MILLISECONDS.sleep(i > 0 ? 100 : 0);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			return client.add(lockKey, token, new Date(expireSec * 1000));
		});
	}

	/**
	 * 通过 del(lockKey) 释放锁
	 *
	 * @param lockKey 上锁的 key
	 * @param token key 对应的 value
	 * @return
	 */
	public boolean release(String lockKey, String token) {
		Object obj = client.get(lockKey);
		String get = "";
		if (obj instanceof String) {
			get = (String) obj;
		}
		// 通过 token 保证不会释放其他客户端的锁
		return Objects.equals(get, token) && client.delete(lockKey);
	}
}

@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DistributedLock {

	/**
	 * 省略 default 要显示指定一个key
	 */
	String key();

	int expired() default 10;

	int acquireRetry() default 3;
}

@Aspect
@Component
public class DistributedLockAspect {

	@Autowired
	MemCacheLock lockService;

	@Around("@annotation(distributedLock)")
	public Object runWithLock(ProceedingJoinPoint pjp, DistributedLock distributedLock) throws Throwable {
		int expired = distributedLock.expired();
		int retry = distributedLock.acquireRetry();
		String key = "dist_lock_" + distributedLock.key();

		long l = (System.currentTimeMillis() / 1000) + Thread.currentThread().hashCode();
		String token = String.valueOf(l);

		boolean acquired = false;
		try {
			acquired = lockService.acquire(key, retry, expired, token);
			if (acquired) {
				return pjp.proceed();
			}
		} finally {
			if (acquired) {
				lockService.release(key, token);
			}
		}

		throw new RuntimeException("can not acquire lock");
	}
}