需求： 在并发情况下，根据不同的id，查询库中数据，放在内存中，仅仅第一次查库，下次查询不再查库。。
思路：查询时，将id加锁，第一个获取锁的，就先查询，放入缓存中。后面获取锁的，先判断缓存
最开始按造下面设计：
private static final ConcurrentMap<String, String> KEYMAP = new ConcurrentHashMap<String, String>();
//开始从缓存map中取，取不到往下查
public static String getKey(String keyId) throws Exception {
String content = KEYMAP.get(keyId);
if (null == content) {
content = loadKey(keyId);
} else {
System.out.println("时间+--" + System.currentTimeMillis() + "，" + Thread.currentThread().getName() + "Map已获取，直接返回");
}
return content;
}
//同步控制，对keyId加锁，同一个keyId的只查一次数据库，不同id互不影响
public static String loadKey(String keyId) throws Exception {
synchronized (keyId) {//错误在这
String content = KEYMAP.get(keyId);
if (null != content) {
System.out.println("时间：" + System.currentTimeMillis() + "，" + Thread.currentThread().getName() + "【进入同步块直接返回】。。。。");
return content;
}
System.out.println("时间：" + System.currentTimeMillis() + "，" + Thread.currentThread().getName() + "【开始查询数据库】。。。。");
Thread.sleep(2222);
System.out.println("时间：" + System.currentTimeMillis() + "，" + Thread.currentThread().getName() + "id" + keyId + "获取缓存为" + "4525262");
KEYMAP.put(keyId, "4525262");
return content;
}
}
public static void main(String aa[]) {
for (int i = 0; i < 10; i++) {
new Thread("线程-" + i + "-") {
@Override
public void run() {
try {
//测试10个线程同时查询id为'1'的数据
KeyLoadUtil.getKey(new String("1"));
} catch (Exception e) {
e.printStackTrace();
}
}
}.start();
}
}
预想结果：
将上面的keyId加锁，10个线程，当同时查询同一个keyid时候，第一个获取到keyid锁的线程，会查询一次数据库，后面的不再查询，直接从map中读取。
而实际并不是如此：
可以看到上图中，10个线程，同时进入了同步块，synchronized (keyId)这句话并没有起到作用。
要知道当synchronized在作用在同一个对象上才有用，想当然的认为，每次进来的String都是”1”，而且每个”1”都是相互equals，hashcode也相等，属于同一对象，可以锁住。。但是，实际上测试并不是，因为String类重写了equals和hashcode方法，所以正常情况使用equals方法没有问题。。如果使用System.identityHashCode(keyId)，可以发现这10个‘keyid’真正的hashcode却是不同，所以在根本上来说并不是同一个对象。
通过System.out.println(“真正code”+System.identityHashCode(keyId)); 打印真正的hashcode可以发现，10个对象真实地址都不相同，如下图
解决办法：
解决办法也很简单：只要将synchronized (keyId) 改成synchronized (keyId.intern()) 即可。
String#intern方法中看到，这个方法是一个 native 的方法，但注释写的非常明了。“如果常量池中存在当前字符串, 就会直接返回当前字符串. 如果常量池中没有此字符串, 会将此字符串放入常量池中后, 再返回”。
所以每次返回同一个对象。
注：在海量不同keyid数据情况下，不建议用keyId.intern()，虽然keyId.intern()节省了大量内存空间（具体可以查查，大概就是同值的地址指向同一个地址），但是海量数据情况下keyId.intern()确是相当耗时。
如下是测试耗时，何时使用根据自身系统考量
int MAX = 1000;
long start = System.currentTimeMillis();
String[] arr = new String[MAX];
for (int i = 0; i < MAX; i++) {
arr[i] = (i+"");
}
System.out.println("原始方法耗时"+String.valueOf(System.currentTimeMillis()-start));
long startintern = System.currentTimeMillis();
String[] arr2 = new String[MAX];
for (int i = 0; i < MAX; i++) {
arr2[i] = (i+"").intern();
}
System.out.println("intern方法耗时"+String.valueOf(System.currentTimeMillis()-startintern));
MAX为1000笔时，原始1ms，intern 1ms
MAX为10000笔时,原始4ms，intern 4ms
MAX为100000笔时，此时耗时已经有明显不同了,原始16ms，intern 115ms
MAX为1000000笔时，原始方式只要272ms，而intern却是13446ms
所以一般在字符范围变法不大情况使用
原文链接：https://blog.csdn.net/a718515028/article/details/80003355
