本文介绍使用java synchronized同步锁来实现对相同userId进行加锁

众所周知synchronized只能锁对象地址，而对于如下加锁是完全没有用的

public void test(Long userId) {

synchronized (userId) {//除了-127-128外其他的值都锁不住

// ...

}

}

原因就在于±127之外的都是new除来的Long(见源码Long.valueOf)，地址值当然不一样了。

既然synchronized需要同一个对象，那我们将同一对象缓存下来不就得了。

private HashMapmMap = new HashMap<>();

public Long getLock(Long userId) {

if (!mMap.containsKey(userId)) {

mMap.put(userId, userId);

}

return mMap.get(userId);

}

思路是对的，但：getLock本身就会有并发问题；每个需要锁的接口都得new一个全局的HashMap；当10000个用户调用了100个接口总计要保存1000000条userId在内存里，服务器运行时间越长积累越多。

于是改成了如下方式，代码虽长了一点，但效率几乎没有下降：

/**

* 由于synchronized只能锁对象的地址，所有像Long为1000的用户id是锁不住的

* 此类来解决这个问题

* synchronized (UserLockUtils.getLock("test" + userId)) {}

* 因为是全局的入参当然是"接口名+userId"最好了

*/

public class UserLockUtils {

private static HashMapmMapId = new HashMap<>(), mMapIdCache = new HashMap<>();

/**

* 缓存切换的开始时间，等待{@link #mCacheDeleteTime}时间后将清空切换数据

*/

private static long mCacheCreatTime;

/**

* 最大缓存数(当超出这一数值时，会自动清空)，缓存切换等待时间

*/

private static int mMaxCache = 1000, mCacheDeleteTime = 10000;

public static synchronized String getLock(String oldId) {

String returnSt;

if (mMapId.size() < mMaxCache) {//数据比较少，普通的返回锁

if (!mMapId.containsKey(oldId)) {

mMapId.put(oldId, oldId);

}

returnSt = mMapId.get(oldId);

} else {//累加的残留数据太多，切换至缓存

//缓存开始时间

long nowMills = System.currentTimeMillis();

if (mMapIdCache.size() == 0) {

mCacheCreatTime = nowMills;

}

if (!mMapIdCache.containsKey(oldId)) {

mMapIdCache.put(oldId, mMapId.getOrDefault(oldId, oldId));

}

returnSt = mMapIdCache.get(oldId);

//等待mCacheChangeTime时间后清除原始数据

if (nowMills - mCacheCreatTime > mCacheDeleteTime) {

mMapId.clear();

//原始和缓存对调即可实现切换

HashMapchange = mMapId;

mMapId = mMapIdCache;

mMapIdCache = change;

}

}

return returnSt;

}

}

举例：登录接口，我们只需要传“接口名+userId”就可以对登录接口的userId加锁了。

public void login(Long userId) {

synchronized (UserLockUtils.getLock("login" + userId)) {

// ...

}

}

尽量不要直接传userId哦，如果所有接口都直接传userId估计就锁死了。