java - 多线程环境中的对象深度锁定

Question

在我的项目中，A 类 和B 类 的类结构如下:

class A {
    private String id;
    private List<B> bs = new ArrayList<B>();

    A(String id){
        this.id = id;
    }

    public List<B> getBs(){
        return bs;
    }

    public void setBs(List<B> bs){
        this.bs=bs;
    }

    public void addBs(List<B> bs){
        this.bs.addAll(bs);
    }

    public void addB(B b){
        this.bs.add(b);
    }
}

class B {
    private String id;
    private List<String> tags;

    B(String id){
        this.id = id;
    }

    public List<String> getTags(){
        return tags;
    }

    public void setTags(List<String> tags){
        this.tags = tags;
    }

    public void addTags(List<String> tags){
        this.tags.addAll(tags);
    }

    public void addTag(String tag){
        this.tags.add(tag);
    }
}

我们还有一个缓存类:

class CacheService {
    private static final ConcurrentHashMap<String, Object> CACHE = new ConcurrentHashMap<String, Object>();

    public static Object get(String id){
        return CACHE.get(id);
    }

    public static void put(String id, Object obj){
        return CACHE.put(id, obj);
    }
}

现在类 A 和 B 的对象是使用唯一 ID 创建的，并通过 组合放入此缓存中。例如:

A a1 = new A("10");
CacheService.put("10", a1);

A a2 = new A("11");
CacheService.put("11", a2);

B b1 = new B("1");
CacheService.put("1", b1);

B b2 = new B("2");
CacheService.put("2", b2);

B b3 = new B("3");
CacheService.put("3", b3);

B b4 = new B("4");
CacheService.put("4", b4);

另外，我将 B 类对象放在 List<B> 中内部对象 a1和 a2 . 重要的是要注意，唯一的 B 对象只在任何 A 对象中放置一次:

a1.add(b1);
a1.add(b2);

a2.add(b3);
a2.add(b4);

这样我们就可以在 CACHE 中有多个 A 类和 B 类的对象。

场景:现在有多个线程访问此 CACHE，但其中一些线程最终获得 A 类对象，而其他线程最终根据用户指定的 ID 获得 B 类对象。这些线程实际上想要读取或更新这些对象的信息。

问题:我的要求是，当一个线程访问了类 A 的对象(例如 a1)以更新它时，其他线程不应该能够读取 或更新 a1以及添加到 b1 的所有 B 类对象(在本例中为 b2 和 List<B>)内部对象 a1直到我完成所有关于 a1 的更新.请告诉我在这种情况下如何获得锁？

Answer 1

要进行深度复制，我建议您使用 Lock在 A 和 B 的每个实例中，让它们都使用 lock() 和 unlock() 方法实现一些接口(interface)，其中类 A 将获取它自己的锁，以及 B 的所有锁。然后，在使用前锁定一个对象，并在使用完毕后解锁。

编辑:所以你的行动方针是:

1. 创建一个接口(interface)，我们称它为 Lockable，有两个方法:lock() 和 unlock()
2. 让 A 和 B 实现该接口(interface)。因此，您的缓存现在将使用 Lockable 而不是 Object
进行操作

3. 为A和B添加一个私有(private)字段

   private final Lock lock = new ReentrantLock ();

4. 现在 B 中 Lockable 的实现将只是调用锁上的相同方法
5. 在 A 中，lock() 将获取锁的本地实例，并迭代 b 的列表并调用它们的 lock() 方法。 unlock()
相同
6. 现在，每次您从缓存中获取一个对象时，在对其进行任何操作之前，您都会对该对象调用 lock()，然后在您调用该对象时调用 unlock()完成了。