2

假设我有以下内容：

public class Foo {
    private ReadingList mReadingList = new ReadingList();

    public ReadingList getReadingList() {
        synchronized (mReadingList) {
            return mReadingList;
        }
    }
}

如果我尝试在两个线程中修改 ReadingList 对象，上面的同步对我没有帮助，对吧？：

// Thread 1
foo1.getReadingList().setName("aaa");

// Thread 2
foo2.getReadingList().setName("bbb");

我是否必须像这样包装我想要同步的每个方法：

public class Foo {
    private ReadingList mReadingList = new ReadingList();

    public synchronized void setReadingListName(String name) {
        mReadingList.setName(name);
    }

    public synchronized void setReadingListAuthor(String author) {
        mReadingList.setAuthor(author);
    }

    ...

对于我想要公开和同步的每个 ReadingList 方法，等等？我最终只会为 ReadingList 的每个方法编写包装器方法。

谢谢

4

2 回答 2

1

1. 您可以访问 ReadingList 源

如果您有权访问 ReadingList 对象，synchronized如果您希望同步访问所有字段，则添加到 ReadingList 的所有方法，或者如果您只希望交叉访问某些字段，则添加到 ReadingList 的所有方法。

2. 您无权访问 ReadingList

您必须编写如下内容：

public class Foo {
    private ReadingList mReadingList = new ReadingList();

    public void setReadingListName(String name) {
        synchronized(mReadingList) {
           mReadingList.setName(name);
        }
    }

    public void setReadingListAuthor(String author) {
        synchronized(mReadingList) {
           mReadingList.setAuthor(author);
        }
    }

    ...

3.使用通用锁对象

根据 Foo 的性质以及整个事情的通用性，您可能会发现只有某个或某些类会在 ReadingList 中出现线程问题。

在这样的类中，您可以使用通用锁定对象：

public class Bar {
   Object readingListLock = new Object();

   public void someMethodThatModifiesReading() {
      synchronized(readingListLock) {
          foo.getReadingList().setName("1");
      }
   }

   public void someOtherMethodThatModifiesReading() {
      synchronized(readingListLock) {
          foo.getReadingList().setName("2");
      }
   }

   ...
}
于 2012-06-30T15:01:22.657 回答
1

一个快速（但不是那么有效的解决方案）是同步ReadingListinReadingList实现的所有方法。

寻找 Reader-Writer 锁以获得更有效的同步访问方式：它允许一次多次读取和一次写入。

您的第一个解决方案只确保一个线程ReadingList一次获得，而没有其他 - 许多线程可以同时读取和修改ReadingList。

于 2012-06-30T15:01:55.070 回答