避免在对象上使用同步锁

Question

下面的方法位于SocketManager类中，后台线程每60秒调用一次。它将ping一个套接字，检查它是否处于活动状态，并将所有内容放在LiveSocketsByDataCenter映射中。

  private final Map<Datacenters, List<SocketHolder>> liveSocketsByDatacenter =
      new ConcurrentHashMap<>();

  // runs every 60 seconds to ping all the socket to make sure whether they are alive or not
  private void updateLiveSockets() {
    Map<Datacenters, List<String>> socketsByDatacenter = Utils.SERVERS;

    for (Map.Entry<Datacenters, List<String>> entry : socketsByDatacenter.entrySet()) {
      List<SocketHolder> liveSockets = liveSocketsByDatacenter.get(entry.getKey());
      List<SocketHolder> liveUpdatedSockets = new ArrayList<>();
      for (SocketHolder liveSocket : liveSockets) {
        Socket socket = liveSocket.getSocket();
        String endpoint = liveSocket.getEndpoint();
        Map<byte[], byte[]> holder = populateMap();
        Message message = new Message(holder, Partition.COMMAND);

        // pinging to see whether a socket is live or not
        boolean status = SendToSocket.getInstance().execute(message.getAdd(), holder, socket);
        boolean isLive = (status) ? true : false;

        SocketHolder zmq = new SocketHolder(socket, liveSocket.getContext(), endpoint, isLive);
        liveUpdatedSockets.add(zmq);
      }
      liveSocketsByDatacenter.put(entry.getKey(), Collections.unmodifiableList(liveUpdatedSockets));
    }
  }

另外，我在同一个SocketManager类中有以下方法。getNextSocket()方法将由多个读取线程（假设最多10个线程）同时调用，以获取下一个活动的套接字。

  // this method will be called by multiple threads concurrently to get the next live socket
  public Optional<SocketHolder> getNextSocket() {
    for (Datacenters dc : Datacenters.getOrderedDatacenters()) {
      Optional<SocketHolder> liveSocket = getLiveSocket(liveSocketsByDatacenter.get(dc));
      if (liveSocket.isPresent()) {
        return liveSocket;
      }
    }
    return Optional.absent();
  }

  private Optional<SocketHolder> getLiveSocket(final List<SocketHolder> listOfEndPoints) {
    if (!listOfEndPoints.isEmpty()) {
      // The list of live sockets
      List<SocketHolder> liveOnly = new ArrayList<>(listOfEndPoints.size());
      for (SocketHolder obj : listOfEndPoints) {
        if (obj.isLive()) {
          liveOnly.add(obj);
        }
      }
      if (!liveOnly.isEmpty()) {
        // The list is not empty so we shuffle it an return the first element
        return Optional.of(liveOnly.get(random.nextInt(liveOnly.size()))); // just pick one
      }
    }
    return Optional.absent();
  }

• 如果计时器线程在updatelivesockets()方法中的socketa上工作，那么所有这10个线程都应该在其他活动套接字上工作（这10个线程中的每一个都在不同的活动套接字上工作）
• 和所有这10个线程应该始终在不同的活动套接字上工作。
• 还有，如果我们有更多的读取线程比我们有活套接字可用，那么我仍然需要确保每个读取线程工作在不同的活套接字上。一旦一个读线程使用活动套接字完成，其他读线程就可以立即使用该套接字或任何更好的方法。我想尽可能减少阻塞时间。

解决这个问题的最好办法是什么？我可以让synchronize，从这10个读取线程加上定时器线程在一个套接字上同步，这将保证只有线程在该套接字上工作，但我不想在这里使用同步。必须有更好的方法来确保每个线程同时使用不同的单个活动套接字，而不是在特定的套接字上同步。我有大约60个插座和大约10个阅读器线程加上1个定时器线程。这里需要使用ThreadLocal概念吗？

Answer 1

解决问题的最佳方案是使用ConcurrentQueue，而不需要使用ThreadLocal。ConcurrentQueue是非阻塞的，对于多线程环境非常高效。例如，这就是如何删除不活动的套接字并保留活动的套接字。

    private final Map<Datacenters, ConcurrentLinkedQueue<SocketHolder>> liveSocketsByDatacenter =
          new ConcurrentHashMap<>();


// runs every 60 seconds to ping 70 sockets the socket to make sure whether they are alive or not (it does not matter if you ping more sockets than there are in the list because you are rotating the que)
  private void updateLiveSockets() {
    Map<Datacenters, List<String>> socketsByDatacenter = Utils.SERVERS;

    for (Map.Entry<Datacenters, List<String>> entry : socketsByDatacenter.entrySet()) {
    Queue<SocketHolder> liveSockets = liveSocketsByDatacenter.get(entry.getKey());
      for (int i = 0; i<70; i++) {
            SocketHolder s = liveSockets.poll();
        Socket socket = s.getSocket();
        String endpoint = s.getEndpoint();
        Map<byte[], byte[]> holder = populateMap();
        Message message = new Message(holder, Partition.COMMAND);

        // pinging to see whether a socket is live or not
        boolean status = SendToSocket.getInstance().execute(message.getAdd(), holder, socket);
        boolean isLive = (status) ? true : false;

        SocketHolder zmq = new SocketHolder(socket, s.getContext(), endpoint, isLive);
        liveSockets.add(zmq);
      }
    }
  }