基于Consul的分布式信号量实现

public class Semaphore {

private Logger logger = Logger.getLogger(getClass());

private static final String prefix = “semaphore/”; // 信号量参数前缀

private ConsulClient consulClient;

private int limit;

private String keyPath;

private String sessionId = null;

private boolean acquired = false;

/**

• @param consulClient consul客户端实例

• @param limit 信号量上限值

• @param keyPath 信号量在consul中存储的参数路径

*/

public Semaphore(ConsulClient consulClient, int limit, String keyPath) {

this.consulClient = consulClient;

this.limit = limit;

this.keyPath = prefix + keyPath;

}

/**

• acquired信号量

• @param block 是否阻塞。如果为true，那么一直尝试，直到获取到该资源为止。

• @return

• @throws IOException

*/

public Boolean acquired(boolean block) throws IOException {

if(acquired) {

logger.error(sessionId + " - Already acquired");

throw new RuntimeException(sessionId + " - Already acquired");

}

// create session

clearSession();

this.sessionId = createSessionId(“semaphore”);

logger.debug("Create session : " + sessionId);

// add contender entry

String contenderKey = keyPath + “/” + sessionId;

logger.debug("contenderKey : " + contenderKey);

PutParams putParams = new PutParams();

putParams.setAcquireSession(sessionId);

Boolean b = consulClient.setKVValue(contenderKey, “”, putParams).getValue();

if(!b) {

logger.error("Failed to add contender entry : " + contenderKey + ", " + sessionId);

throw new RuntimeException("Failed to add contender entry : " + contenderKey + ", " + sessionId);

}

while(true) {

// try to take the semaphore

String lockKey = keyPath + “/.lock”;

String lockKeyValue;

GetValue lockKeyContent = consulClient.getKVValue(lockKey).getValue();

if (lockKeyContent != null) {

// lock值转换

lockKeyValue = lockKeyContent.getValue();

BASE64Decoder decoder = new BASE64Decoder();

byte[] v = decoder.decodeBuffer(lockKeyValue);

String lockKeyValueDecode = new String(v);

logger.debug(“lockKey=” + lockKey + “, lockKeyValueDecode=” + lockKeyValueDecode);

Gson gson = new Gson();

ContenderValue contenderValue = gson.fromJson(lockKeyValueDecode, ContenderValue.class);

// 当前信号量已满

if(contenderValue.getLimit() == contenderValue.getHolders().size()) {

logger.debug("Semaphore limited " + contenderValue.getLimit() + “, waiting…”);

if(block) {

// 如果是阻塞模式，再尝试

try {

Thread.sleep(100L);

} catch (InterruptedException e) {

}

continue;

}

// 非阻塞模式，直接返回没有获取到信号量

return false;

}

// 信号量增加

contenderValue.getHolders().add(sessionId);

putParams = new PutParams();

putParams.setCas(lockKeyContent.getModifyIndex());

boolean c = consulClient.setKVValue(lockKey, contenderValue.toString(), putParams).getValue();

if© {

acquired = true;

return true;

}

else

continue;

} else {

// 当前信号量还没有，所以创建一个，并马上抢占一个资源

ContenderValue contenderValue = new ContenderValue();

contenderValue.setLimit(limit);

contenderValue.getHolders().add(sessionId);

putParams = new PutParams();

putParams.setCas(0L);

boolean c = consulClient.setKVValue(lockKey, contenderValue.toString(), putParams).getValue();

if © {

acquired = true;

return true;

}

continue;

}

}

}

/**

• 创建sessionId

• @param sessionName

• @return

*/

public String createSessionId(String sessionName) {

NewSession newSession = new NewSession();

newSession.setName(sessionName);

return consulClient.sessionCreate(newSession, null).getValue();

}

/**

• 释放session、并从lock中移除当前的sessionId

• @throws IOException

*/

public void release() throws IOException {

if(this.acquired) {

// remove session from lock

while(true) {

String contenderKey = keyPath + “/” + sessionId;

String lockKey = keyPath + “/.lock”;

String lockKeyValue;

GetValue lockKeyContent = consulClient.getKVValue(lockKey).getValue();

if (lockKeyContent != null) {

// lock值转换

lockKeyValue = lockKeyContent.getValue();

BASE64Decoder decoder = new BASE64Decoder();

byte[] v = decoder.decodeBuffer(lockKeyValue);

String lockKeyValueDecode = new String(v);

Gson gson = new Gson();

ContenderValue contenderValue = gson.fromJson(lockKeyValueDecode, ContenderValue.class);

contenderValue.getHolders().remove(sessionId);

PutParams putParams = new PutParams();

putParams.setCas(lockKeyContent.getModifyIndex());

consulClient.deleteKVValue(contenderKey);

boolean c = consulClient.setKVValue(lockKey, contenderValue.toString(), putParams).getValue();

if© {

break;

}

}

}

// remove session key

}

this.acquired = false;

clearSession();

}

public void clearSession() {

if(sessionId != null) {

consulClient.sessionDestroy(sessionId, null);

sessionId = null;

}

}

class ContenderValue implements Serializable {

private Integer limit;

private List holders = new ArrayList<>();

public Integer getLimit() {

return limit;

}

public void setLimit(Integer limit) {

this.limit = limit;

}

public List getHolders() {

return holders;

}

public void setHolders(List holders) {

this.holders = holders;

}

@Override

public String toString() {

return new Gson().toJson(this);

}

}

}

单元测试

---

下面单元测试的逻辑：通过线程的方式来模拟不同的分布式服务来获取信号量执行业务逻辑。由于信号量与简单的分布式互斥锁有所不同，它不是只限定一个线程可以操作，而是可以控制多个线程的并发，所以通过下面的单元测试，我们设置信号量为3，然后同时启动15个线程来竞争的情况，来观察分布式信号量实现的结果如何。

public class TestLock {

private Logger logger = Logger.getLogger(getClass());

@Test

public void testSemaphore() throws Exception {

new Thread(new SemaphoreRunner(1)).start();

new Thread(new SemaphoreRunner(2)).start();

new Thread(new SemaphoreRunner(3)).start();

new Thread(new SemaphoreRunner(4)).start();

new Thread(new SemaphoreRunner(5)).start();

new Thread(new SemaphoreRunner(6)).start();

new Thread(new SemaphoreRunner(7)).start();

最后

关于面试刷题也是有方法可言的，建议最好是按照专题来进行，然后由基础到高级，由浅入深来，效果会更好。当然，这些内容我也全部整理在一份pdf文档内，分成了以下几大专题：

• Java基础部分

• 算法与编程

• 数据库部分

• 流行的框架与新技术（Spring+SpringCloud+SpringCloudAlibaba）

这份面试文档当然不止这些内容，实际上像JVM、设计模式、ZK、MQ、数据结构等其他部分的面试内容均有涉及，因为文章篇幅，就不全部在这里阐述了。

作为一名程序员，阶段性的学习是必不可少的，而且需要保持一定的持续性，这次在这个阶段内，我对一些重点的知识点进行了系统的复习，一方面巩固了自己的基础，另一方面也提升了自己的知识广度和深度。
份pdf文档内，分成了以下几大专题：

• Java基础部分

[外链图片转存中…(img-TrAsa9dA-1719192828076)]

• 算法与编程

[外链图片转存中…(img-XuV8Li9t-1719192828077)]

• 数据库部分

[外链图片转存中…(img-lngKE9vr-1719192828077)]

• 流行的框架与新技术（Spring+SpringCloud+SpringCloudAlibaba）

[外链图片转存中…(img-GWK5y0x8-1719192828078)]

这份面试文档当然不止这些内容，实际上像JVM、设计模式、ZK、MQ、数据结构等其他部分的面试内容均有涉及，因为文章篇幅，就不全部在这里阐述了。

作为一名程序员，阶段性的学习是必不可少的，而且需要保持一定的持续性，这次在这个阶段内，我对一些重点的知识点进行了系统的复习，一方面巩固了自己的基础，另一方面也提升了自己的知识广度和深度。