主页 / 问题 / 1058327
Accepted
Miron
Asked:2020-12-13 23:47:29 +0000 UTC2020-12-13 23:47:29 +0000 UTC

如何一次同步多个对象？

  • 772

一个对象要同步？是的，请！

Object object = new Object();
synchronized(object) {
    // действия с ним
}

而且，在这里，如何同步某个对象列表？不要写成相互嵌套的同一套synchronized。

java

2 个回答

  1. 我们可以同步的不是对象，而是流。您在块synchronized中使用的对象用于捕获其中的所谓监视器。在给定的时间，只有一个线程可以抓取并持有一个监视器。其他试图这样做的线程进入等待模式。对象的监视器在退出块后synchronized或什至更早 - 在运行wait()此块内的方法的变体之一之后被释放。同步方法是常规方法的较短形式，其所有代码都在synchronized. 在这种情况下，如果方法是正常的，则同步对象变为this，如果方法是静态的，则变为此类。

    如果您确实需要，您可以将线程与多个对象同步，但在这种情况下，您执行的顺序很重要。如果多个对象获取和释放监视器的顺序不一样，很容易陷入死锁或死锁状态。

    • 3
  2. Best Answer

    您一次可以同步一个对象。如果需要同步多个，则必须编写嵌套块。但我不建议这样做——如果你有很多嵌套块，那么你可能做错了什么。

    举个例子，让有一个类

    static class MySyncDemo{
    private Object[] myArray = new Object[] {new Object()};

    public void RunArraySynced() throws InterruptedException {
        synchronized (myArray){
            while (true){
                System.out.println("RunArraySynced");
                Thread.sleep(1000);
            }
        }
    }

    public void RunObjectSynced() throws InterruptedException {
        synchronized (myArray[0]){
            while (true){
                System.out.println("RunObjectSynced");
                Thread.sleep(1000);
            }
        }
    }
}

    让我们尝试并行调用它

    public static void main(String[] args) throws IOException {

    MySyncDemo demo = new MySyncDemo();

    Thread t1 = new Thread(()->{
        try {
            demo.RunArraySynced();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    });

    Thread t2 = new Thread(()->{
        try {
            demo.RunObjectSynced();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    });

    t1.start();
    t2.start();

    BufferedReader obj = new BufferedReader(new InputStreamReader(System.in));
    obj.readLine();

    t1.interrupt();
    t2.interrupt();
}

    在输出我们得到

    RunArraySynced
RunObjectSynced
RunArraySynced
RunObjectSynced
RunObjectSynced
RunArraySynced
RunObjectSynced
RunArraySynced

    这表明数组同步不同步数组元素。

    此外，在他们谈论同步块的段落中的java doc中，他们只谈论对象，没有关于数组的词：链接到这个段落。

    事实上，为了保护数组免受并发访问，不需要在数组上进行同步。只需要同步阵列上的操作。

    考虑下面的类

    public class SynchronizedArray<T> {

    private ArrayList<T> _innerArray;
    private Object _syncObject = new Object();

    public SynchronizedArray(int capacity) {
        _innerArray = new ArrayList<>(capacity);
    }

    public void AddItem(int index, T item) {
        synchronized (_syncObject) {
            _innerArray.add(index, item);
        }
    }

    public void RemoveItem(int index) {
        synchronized (_syncObject) {
            _innerArray.remove(index);
        }
    }
}

    我们看到的：

    1. 这是一个单独的类，提供对私有数组字段的访问。除了这个类之外，没有人可以访问该数组。因此，我们可以完全控制数组上的所有操作。

    2. 已选择一个单独的对象进行同步 - 原因有很多：

      • 我们不能使用数组进行同步，因为数组在语义上只是类数据，数组的职责是存储数据。该数组可以随时重新创建，但操作仍必须同步。
      • 我们不能使用它来同步，因为它是对包装器对象本身的引用，它可供外部世界使用。也就是说，调用代码可以尝试在某处执行以下操作：
        SynchronizedArray<Integer> array = new SynchronizedArray<>(10);
    synchronized (array){
        ....
    }

    也就是说，在此同步时，必须记住调用代码也可以在其上同步。为了降低这种复杂性并避免线程死锁的潜在问题，我在类中创建了一个私有字段private Object _syncObject = new Object();，只有我们的类可以在该字段上进行同步，并且该字段在其他任何地方都不可用。

    这种方法使多个线程可以使用并非设计为在多线程环境中工作的数据结构。

    这是最简单也是最笨拙的方式，实际上，对对象的操作往往支持不同程度的并发。例如，多线程读取数组的元素是安全的，但写入数组必须是单线程的。在这种情况下，使用更高级的锁（例如，ReaderWriterLock）

    附言。我不是java专家，我自己还在学习它，所以欢迎指出错误。

    • 2

相关问题