1200页Java架构面试专题及答案
小编整理不易,对这份1200页Java架构面试专题及答案感兴趣劳烦帮忙转发/点赞
百度、字节、美团等大厂常见面试题
肝代码
有了以上理论做基础,我们开始etcd分布式锁的代码实现。
jetcd客户端
jetcd是etcd的Java客户端,它提供了丰富的接口来操作etcd,使用方便。
redis数据准备
初始化库存stock=300,再设置一个lucky=0,表示抢到库存的人,实际场景中可以是用户订单信息,每扣减一个库存,lucky便加1。
etcd分布式锁的实现
由于etcd的Lock接口有一套自己的实现,zookeeper的Lock接口也有自己的一套实现,redis…各种分布式锁实现方案都有自己的Lock,因此,我封装了一个模板方法:
/**
- @program: distributed-lock
- @description: 各种分布式锁的基类,模板方法
- @author: 行百里者
- @create: 2020/10/14 12:29
**/
public class AbstractLock implements Lock {
@Override
public void lock() {
throw new RuntimeException(“请自行实现该方法”);
}
@Override
public void lockInterruptibly() throws InterruptedException {
throw new RuntimeException(“请自行实现该方法”);
}
@Override
public boolean tryLock() {
throw new RuntimeException(“请自行实现该方法”);
}
@Override
public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
throw new RuntimeException(“请自行实现该方法”);
}
@Override
public void unlock() {
throw new RuntimeException(“请自行实现该方法”);
}
@Override
public Condition newCondition() {
throw new RuntimeException(“请自行实现该方法”);
}
}
有了这个模板方法之后,后续分布式锁的实现均可以继承这个模板方法类。
etcd分布式锁的实现:
@Data
public class EtcdDistributedLock extends AbstractLock {
private final static Logger LOGGER = LoggerFactory.getLogger(EtcdDistributedLock.class);
private Client client;
private Lock lockClient;
private Lease leaseClient;
private String lockKey;
//锁路径,方便记录日志
private String lockPath;
//锁的次数
private AtomicInteger lockCount;
//租约有效期。作用 1:客户端崩溃,租约到期后自动释放锁,防止死锁 2:正常执行自动进行续租
private Long leaseTTL;
//续约锁租期的定时任务,初次启动延迟,默认为1s,根据实际业务需要设置
private Long initialDelay = 0L;
//定时任务线程池
ScheduledExecutorService scheduledExecutorService;
//线程与锁对象的映射
private final ConcurrentMap<Thread, LockData> threadData = Maps.newConcurrentMap();
public EtcdDistributedLock(Client client, String lockKey, Long leaseTTL, TimeUnit unit) {
this.client = client;
this.lockClient = client.getLockClient();
this.leaseClient = client.getLeaseClient();
this.lockKey = lockKey;
this.leaseTTL = unit.toNanos(leaseTTL);
scheduledExecutorService = Executors.newSingleThreadScheduledExecutor();
}
@Override
public void lock() {
}
@Override
public void unlock() {
}
}
其中lock方法的实现:
@Override
public void lock() {
Thread currentThread = Thread.currentThread();
LockData existsLockData = threadData.get(currentThread);
//System.out.println(currentThread.getName() + " 加锁 existsLockData:" + existsLockData);
//锁重入
if (existsLockData != null && existsLockData.isLockSuccess()) {
int lockCount = existsLockData.lockCount.incrementAndGet();
if (lockCount < 0) {
throw new Error(“超出etcd锁可重入次数限制”);
}
return;
}
//创建租约,记录租约id
long leaseId;
try {
leaseId = leaseClient.grant(TimeUnit.NANOSECONDS.toSeconds(leaseTTL)).get().getID();
//续租心跳周期
long period = leaseTTL - leaseTTL / 5;
//启动定时续约
scheduledExecutorService.scheduleAtFixedRate(new KeepAliveTask(leaseClient, leaseId),
initialDelay,
period,
TimeUnit.NANOSECONDS);
//加锁
LockResponse lockResponse = lockClient.lock(ByteSequence.from(lockKey.getBytes()), leaseId).get();
if (lockResponse != null) {
lockPath = lockResponse.getKey().toString(StandardCharsets.UTF_8);
LOGGER.info(“线程:{} 加锁成功,锁路径:{}”, currentThread.getName(), lockPath);
}
//加锁成功,设置锁对象
LockData lockData = new LockData(lockKey, currentThread);
lockData.setLeaseId(leaseId);
lockData.setService(scheduledExecutorService);
threadData.put(currentThread, lockData);
lockData.setLockSuccess(true);
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
}
简而言之,加锁的代码就是按照如下步骤来的:
- 检查锁重入性
- 设置租约
- 开启定时任务心跳检查
- 阻塞获取锁
- 加锁成功,设置锁对象
业务处理完成(扣减库存)后,解锁:
@Override
public void unlock() {
Thread currentThread = Thread.currentThread();
//System.out.println(currentThread.getName() + " 释放锁…“);
LockData lockData = threadData.get(currentThread);
//System.out.println(currentThread.getName() + " lockData " + lockData);
if (lockData == null) {
throw new IllegalMonitorStateException(“线程:” + currentThread.getName() + " 没有获得锁,lockKey:” + lockKey);
}
int lockCount = lockData.lockCount.decrementAndGet();
if (lockCount > 0) {
return;
}
if (lockCount < 0) {
throw new IllegalMonitorStateException(“线程:” + currentThread.getName() + " 锁次数为负数,lockKey:" + lockKey);
}
try {
//正常释放锁
if (lockPath != null) {
lockClient.unlock(ByteSequence.from(lockPath.getBytes())).get();
}
//关闭续约的定时任务
lockData.getService().shutdown();
//删除租约
if (lockData.getLeaseId() != 0L) {
leaseClient.revoke(lockData.getLeaseId());
}
} catch (InterruptedException | ExecutionException e) {
//e.printStackTrace();
LOGGER.error(“线程:” + currentThread.getName() + “解锁失败。”, e);
} finally {
//移除当前线程资源
threadData.remove(currentThread);
}
LOGGER.info(“线程:{} 释放锁”, currentThread.getName());
}
解锁过程:
- 重入性检查
- 移除当前锁的节点路径释放锁
- 清除重入的线程资源
接口测试
/**
- @program: distributed-lock
- @description: etcd分布式锁演示-高并发下库存扣减
- @author: 行百里者
- @create: 2020/10/15 13:24
**/
@RestController
public class StockController {
private final StringRedisTemplate redisTemplate;
@Value(“${server.port}”)
private String port;
@Value(“${etcd.lockPath}”)
private String lockKey;
private final Client etcdClient;
public StockController(StringRedisTemplate redisTemplate, @Value(“${etcd.servers}”) String servers) {
最后
金三银四到了,送上一个小福利!
[外链图片转存中…(img-wIdBjPLj-1715368219747)]