2

我正在编写一个多线程程序，并且我有一个具有嵌套同步块的方法，我想知道我是否需要内部同步，或者只是外部同步就足够了。

public class Tester {

    private BlockingQueue<Ticket> q = new LinkedBlockingQueue<>();
    private ArrayList<Long> list = new ArrayList<>();

    public void acceptTicket(Ticket p) {
        try {
            synchronized (q) {
                q.put(p);

                synchronized (list) {
                    if (list.size() < 5) {
                        list.add(p.getSize());
                    } else {
                        list.remove(0);
                        list.add(p.getSize());
                        }
                }
            }
        } catch (InterruptedException ex) {
            Logger.getLogger(Consumer.class.getName()).log(Level.SEVERE, null, ex);
        }

    }
}

编辑：这不是一个完整的课程，因为我仍在努力。但本质上我是在尝试模仿售票机。售票机在BlockingQueueq 中维护一张票的列表。每当客户向机器添加票时，机器也会跟踪最后 5 张票的价格（ArrayList列表）。所以我不相信我需要内部同步，因为只有这个类（票务系统）才能访问list

4

2 回答 2

4

危险：

    synchronized (q) {
        synchronized (list) {
         }
    }

有一天你会添加一个方法，或者以这样的顺序调用方法，实际上它也会这样做：

    synchronized (list) {
        synchronized (q) {
         }
    }

那么这只是一个死锁定时炸弹。

假设这是一个完整的类，您可以只锁定一个，或者通常synchronized在方法上锁定对象本身。对这些私有的所有其他访问也需要同步。

public class Tester {

private BlockingQueue<Ticket> q = new LinkedBlockingQueue<>();
private ArrayList<Long> list = new ArrayList<>();

public synchronized void acceptTicket(Ticket p) {
    try {
      q.put(p);

      if (list.size() < 5) {
        list.add(p.getSize());
      } else {
        list.remove(0);
        list.add(p.getSize());
      }
    } catch (InterruptedException ex) {
        Logger.getLogger(Consumer.class.getName()).log(Level.SEVERE, null, ex);
    }    
}

或更清洁：

public class Tester {

private BlockingQueue<Ticket> q = new LinkedBlockingQueue<>();
private ArrayList<Long> list = new ArrayList<>();

public void acceptTicket(Ticket p) {
    try {
      //this is cleaner, because I don't know what logger class is doing,
      //I want to eliminate chance of deadlock and reduce time we are in lock
      synchronized (this){
        q.put(p);

        if (list.size() < 5) {
          list.add(p.getSize());
        } else {
          list.remove(0);
          list.add(p.getSize());
        }
     }
    } catch (InterruptedException ex) {
        Logger.getLogger(Consumer.class.getName()).log(Level.SEVERE, null, ex);
    }    
}

更清洁，但在你的情况下不太可能是必要的（根据我所看到的）：

public class Tester {

private final Object lockObj = new Object(); //specific object for locking
                                //could use any other private, non-exposed final but
                                //this makes it absolutely clear what I should be
                                //using for locks
private BlockingQueue<Ticket> q = new LinkedBlockingQueue<>();
private ArrayList<Long> list = new ArrayList<>();

public void acceptTicket(Ticket p) {
    try {
      //"this" can be locked by external code outside my control here,
      //so I use a specific private final object lockObj to eliminate deadlocks and
      //provide finer grained locking - reducing contension
      synchronized (lockObj){
        q.put(p);

        if (list.size() < 5) {
          list.add(p.getSize());
        } else {
          list.remove(0);
          list.add(p.getSize());
        }
     }
    } catch (InterruptedException ex) {
        Logger.getLogger(Consumer.class.getName()).log(Level.SEVERE, null, ex);
    }    
}
于 2012-11-03T10:47:00.623 回答
1

看起来上面代码的意图是将所有操作（队列中的存储和列表中的存储）分组在一个原子操作中。所以是的，外部同步块就是你所需要的。一次持有多个锁是结束死锁的好方法，因此应尽可能避免。

不过，我不会将队列本身用作锁，而是使用专用的最终锁对象。

最重要的是：上面的代码本身没有任何意义，因为列表和队列在其他任何地方都没有使用。所以我刚才说的可能是真的，也可能是完全错误的，这取决于实际代码的其余部分。

于 2012-11-03T10:46:28.373 回答