这种方法是否可以在线程安全且没有死锁的情况下工作

Question

public int saveUserToMap(User user) {
    ReentrantLock lock;
    if(this.userLocks.containsKey(user.getId())) {
        lock = this.userLocks.get(user.getId());
    } else {
        lock = new ReentrantLock();
        ReentrantLock check = this.userLocks.putIfAbsent(user.getId(), lock);
        if(check != null)
            lock = check;
    }

    if(lock.isLocked())
        try {
            lock.wait();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    lock.lock();

    this.users.put(user.getId(), user);
    this.usersByName.put(user.getUsername(), user);
    this.usersByEmail.put(user.getEmail(), user);

    lock.unlock();
    lock.notify();

    return user.getId();
}

嘿，我只是想请 Java 开发人员检查我的代码是否是线程安全的并且没有死锁，因为我想在我的项目中使用它。 Users、UsersByName 和 UsersByEmail 是 ConcurrentHashMap，其中 String、Integer 为 key，User 对象为 Value。 UserLocks 是一个 ConcurrentHashMap，其中 Integer（显然用户 id 作为键）和 ReentrantLock 作为值。 我想同步三个HashMap。 如果有人有更好的解决方案来制作包含三个键的并发映射，那么最好将其发布在这里。性能也很重要。

Answer 1

它是线程安全的。

如果 userId 已经在 map 中，代码获取锁并使用它进行同步。如果没有，ConcurrentHashMap 会提供同步以避免竞争条件以对同一 id 使用不同的锁。

之后，有一段无用的代码，你可以去掉：

if(lock.isLocked())
    try {
        lock.wait();
    } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

不需要，因为正在使用lock.lock() 完成同步。不需要尝试使用wait() 和notify() 与锁定对象再次同步。（实际上，它没有按您的预期工作，多个线程可以在同一个锁定对象上调用lock.isLocked() 并得到一个假，直到任何的线程调用lock.lock()，但锁定和解锁之间的所有内容一次只能由一个线程执行）。

此外，通常的良好做法是在 finally 块中调用 lock.unlock()。

Answer 2

我会使用synchronized 以简单的方式完成。

class UserMaps {
    private Map<Integer, User> users = new ConcurrentHashMap<>();
    private Map<String, User> usersByName = new ConcurrentHashMap<>();
    private Map<String, User> usersByEmail = new ConcurrentHashMap<>();

    public synchronized int put(User user) {
        users.put(user.getId(), user);
        usersByName.put(user.getUsername(), user);
        usersByEmail.put(user.getEmail(), user);
        return user.getId();
    }
}

只要您的所有 getter 也是 synchronized，这将确保所有地图都得到一致更新。

但是，如果您想要更好的性能并且想要避免将您的方法全部设为synchronized，那么请使用ReadWriteLock。

class UserMaps {
    ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    private Map<Integer, User> users = new ConcurrentHashMap<>();
    private Map<String, User> usersByName = new ConcurrentHashMap<>();
    private Map<String, User> usersByEmail = new ConcurrentHashMap<>();

    public int saveUserToMap(User user) {
        lock.writeLock().lock();
        try {
            users.put(user.getId(), user);
            usersByName.put(user.getUsername(), user);
            usersByEmail.put(user.getEmail(), user);
            return user.getId();
        } finally {
            lock.writeLock().unlock();
        }
    }

    public User getById(int id) {
        lock.readLock().lock();
        try {
            return users.get(id);
        } finally {
            lock.readLock().unlock();
        }
    }
}