当synchronized 作用在String上（String#intern()）

*需求： 在并发情况下，根据不同的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

所以一般在字符范围变法不大情况使用