单点高并发，针对字符串，读写锁这样写会不会有问题？

Question

public class StringLock {
    private String lockKey;

    private StringLock(String key) {
        this.lockKey = key;
    }

    public void unlock() {
        unlock(this.lockKey);
    }

    private final static List<String> keys;
    static {
        keys = new ArrayList<String>();
    }

    public final static StringLock readLock(String key) {
        String readkey = buildReadStr(key);
        String writekey = buildWriteStr(key);
        synchronized (key.intern()) {
            while (keys.contains(writekey)) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                }
            }
            keys.add(readkey);
        }
        return new StringLock(readkey);
    }

    public final static StringLock writeLock(String key) {
        String readkey = buildReadStr(key);
        String writekey = buildWriteStr(key);
        synchronized (key.intern()) {
            while (keys.contains(readkey) || keys.contains(writekey)) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                }
            }
            keys.add(writekey);
        }
        return new StringLock(writekey);
    }

    private static void unlock(String key) {
        synchronized (key.intern()) {
            keys.remove(key);
        }
    }

    private static String buildReadStr(String str) {
        return StringUtil.toString(str, "-read").intern();
    }

    private static String buildWriteStr(String str) {
        return StringUtil.toString(str, "-write").intern();
    }
}

想知道还有什么更好的实现方案

Answer 1

你可以考虑使用 java.util.concurrent.LinkedBlockingDeque 或类似的并发容器。这样就不需要再代码证加锁了。

另外，如果有这样的场景：需要根据传入的参数来定位锁，建议将锁放在ConcurrentHashMap 中，<key, Lock>，这样根据 key 来定位锁，然后直接使用。

Answer 2

没看明白你的用意。这个StringLock类有何作用？