Java CopyOnWriteArraySet类代码示例

import java.util.concurrent.CopyOnWriteArraySet; //导入依赖的package包/类
@Test public void equalsAndHashCode() throws Exception {
  ConnectionSpec allCipherSuites = new ConnectionSpec.Builder(ConnectionSpec.MODERN_TLS)
      .allEnabledCipherSuites()
      .build();
  ConnectionSpec allTlsVersions = new ConnectionSpec.Builder(ConnectionSpec.MODERN_TLS)
      .allEnabledTlsVersions()
      .build();

  Set<Object> set = new CopyOnWriteArraySet<>();
  assertTrue(set.add(ConnectionSpec.MODERN_TLS));
  assertTrue(set.add(ConnectionSpec.COMPATIBLE_TLS));
  assertTrue(set.add(ConnectionSpec.CLEARTEXT));
  assertTrue(set.add(allTlsVersions));
  assertTrue(set.add(allCipherSuites));

  assertTrue(set.remove(ConnectionSpec.MODERN_TLS));
  assertTrue(set.remove(ConnectionSpec.COMPATIBLE_TLS));
  assertTrue(set.remove(ConnectionSpec.CLEARTEXT));
  assertTrue(set.remove(allTlsVersions));
  assertTrue(set.remove(allCipherSuites));
  assertTrue(set.isEmpty());
}
 

import java.util.concurrent.CopyOnWriteArraySet; //导入依赖的package包/类
private void addSessionChangerListener(SessionChanger sc) {
    Set<String> actions = sc.getActions();
    synchronized (sessionChangers) {
        for (String action : actions) {
            Set<SessionChanger> scs = sessionChangers.get(action);
            if (scs == null) {
                sessionChangers.put(action, Collections.singleton(sc));
            } else {
                if (scs.size() == 1) {
                    SessionChanger old = scs.iterator().next();
                    scs = new CopyOnWriteArraySet<SessionChanger>();
                    scs.add(old);
                }
                scs.add(sc);
            }
        }
    }
}
 

import java.util.concurrent.CopyOnWriteArraySet; //导入依赖的package包/类
@Override
public void start() {
    if (!started) {
        startLock.lock();
        try {
            if (!started) {
                this.eventKey = KEY_PREFIX + UUID.randomUUID().toString().replace("-", "").toLowerCase();
                this.segmentMap = new ConcurrentHashMap<>();
                this.statusMap = new ConcurrentHashMap<>();
                this.brokenServerSet = new CopyOnWriteArraySet<>();
                this.commandQueue = new LinkedBlockingQueue<>();
                this.halfOpenLockMap = new ConcurrentHashMap<>(64);
                this.registerEvent();
                this.startTask();
                started = true;
            }
        } finally {
            startLock.unlock();
        }
    }
}
 

import java.util.concurrent.CopyOnWriteArraySet; //导入依赖的package包/类
/**
 * Constructs an instance. Must be invoked from a thread that has an associated {@link Looper}.
 *
 * @param rendererCount The number of {@link TrackRenderer}s that will be passed to
 *     {@link #prepare(TrackRenderer[])}.
 * @param minBufferMs A minimum duration of data that must be buffered for playback to start
 *     or resume following a user action such as a seek.
 * @param minRebufferMs A minimum duration of data that must be buffered for playback to resume
 *     after a player invoked rebuffer (i.e. a rebuffer that occurs due to buffer depletion, and
 *     not due to a user action such as starting playback or seeking).
 */
@SuppressLint("HandlerLeak")
public ExoPlayerImpl(int rendererCount, int minBufferMs, int minRebufferMs) {
  Log.i(TAG, "Init " + ExoPlayerLibraryInfo.VERSION);
  this.playWhenReady = false;
  this.playbackState = STATE_IDLE;
  this.listeners = new CopyOnWriteArraySet<>();
  this.trackFormats = new MediaFormat[rendererCount][];
  this.selectedTrackIndices = new int[rendererCount];
  eventHandler = new Handler() {
    @Override
    public void handleMessage(Message msg) {
      ExoPlayerImpl.this.handleEvent(msg);
    }
  };
  internalPlayer = new ExoPlayerImplInternal(eventHandler, playWhenReady, selectedTrackIndices,
      minBufferMs, minRebufferMs);
}
 

import java.util.concurrent.CopyOnWriteArraySet; //导入依赖的package包/类
/**
 * Registers all subscriber methods on the given listener object.
 */
void register(Object listener) {
  Multimap<Class<?>, Subscriber> listenerMethods = findAllSubscribers(listener);

  for (Map.Entry<Class<?>, Collection<Subscriber>> entry : listenerMethods.asMap().entrySet()) {
    Class<?> eventType = entry.getKey();
    Collection<Subscriber> eventMethodsInListener = entry.getValue();

    CopyOnWriteArraySet<Subscriber> eventSubscribers = subscribers.get(eventType);

    if (eventSubscribers == null) {
      CopyOnWriteArraySet<Subscriber> newSet = new CopyOnWriteArraySet<Subscriber>();
      eventSubscribers =
          MoreObjects.firstNonNull(subscribers.putIfAbsent(eventType, newSet), newSet);
    }

    eventSubscribers.addAll(eventMethodsInListener);
  }
}
 

import java.util.concurrent.CopyOnWriteArraySet; //导入依赖的package包/类
/**
 * Unregisters all subscribers on the given listener object.
 */
void unregister(Object listener) {
  Multimap<Class<?>, Subscriber> listenerMethods = findAllSubscribers(listener);

  for (Map.Entry<Class<?>, Collection<Subscriber>> entry : listenerMethods.asMap().entrySet()) {
    Class<?> eventType = entry.getKey();
    Collection<Subscriber> listenerMethodsForType = entry.getValue();

    CopyOnWriteArraySet<Subscriber> currentSubscribers = subscribers.get(eventType);
    if (currentSubscribers == null || !currentSubscribers.removeAll(listenerMethodsForType)) {
      // if removeAll returns true, all we really know is that at least one subscriber was
      // removed... however, barring something very strange we can assume that if at least one
      // subscriber was removed, all subscribers on listener for that event type were... after
      // all, the definition of subscribers on a particular class is totally static
      throw new IllegalArgumentException(
          "missing event subscriber for an annotated method. Is " + listener + " registered?");
    }

    // don't try to remove the set if it's empty; that can't be done safely without a lock
    // anyway, if the set is empty it'll just be wrapping an array of length 0
  }
}
 

import java.util.concurrent.CopyOnWriteArraySet; //导入依赖的package包/类
/**
 * Gets an iterator representing an immutable snapshot of all subscribers to the given event at
 * the time this method is called.
 */
Iterator<Subscriber> getSubscribers(Object event) {
  ImmutableSet<Class<?>> eventTypes = flattenHierarchy(event.getClass());

  List<Iterator<Subscriber>> subscriberIterators =
      Lists.newArrayListWithCapacity(eventTypes.size());

  for (Class<?> eventType : eventTypes) {
    CopyOnWriteArraySet<Subscriber> eventSubscribers = subscribers.get(eventType);
    if (eventSubscribers != null) {
      // eager no-copy snapshot
      subscriberIterators.add(eventSubscribers.iterator());
    }
  }

  return Iterators.concat(subscriberIterators.iterator());
}
 

import java.util.concurrent.CopyOnWriteArraySet; //导入依赖的package包/类
public Test testsForCopyOnWriteArraySet() {
  return SetTestSuiteBuilder.using(
          new TestStringSetGenerator() {
            @Override
            public Set<String> create(String[] elements) {
              return new CopyOnWriteArraySet<String>(MinimalCollection.of(elements));
            }
          })
      .named("CopyOnWriteArraySet")
      .withFeatures(
          CollectionFeature.SUPPORTS_ADD,
          CollectionFeature.SUPPORTS_REMOVE,
          CollectionFeature.SERIALIZABLE,
          CollectionFeature.ALLOWS_NULL_VALUES,
          CollectionFeature.KNOWN_ORDER,
          CollectionSize.ANY)
      .suppressing(suppressForCopyOnWriteArraySet())
      .createTestSuite();
}
 

import java.util.concurrent.CopyOnWriteArraySet; //导入依赖的package包/类
/**
 * Creates a new client transaction.
 * 
 * @param newSIPStack Transaction stack this transaction belongs to.
 * @param newChannelToUse Channel to encapsulate.
 * @return the created client transaction.
 */
protected SIPClientTransactionImpl(SIPTransactionStack newSIPStack, MessageChannel newChannelToUse)
{
  super(newSIPStack, newChannelToUse);
  // Create a random branch parameter for this transaction
  setBranch(Utils.getInstance().generateBranchId());
  this.setEncapsulatedChannel(newChannelToUse);
  this.notifyOnRetransmit = false;
  this.timeoutIfStillInCallingState = false;

  if (logger.isLoggingEnabled(LogWriter.TRACE_DEBUG)) {
    logger.logDebug("Creating clientTransaction " + this);
    logger.logStackTrace();
  }
  // this.startTransactionTimer();
  this.sipDialogs = new CopyOnWriteArraySet<String>();
}
 

import java.util.concurrent.CopyOnWriteArraySet; //导入依赖的package包/类
public synchronized HostTable addRoute(H host, String virtualHost, String contextPath) {
    Set<Target> hostData = hosts.get(host);
    if(hostData == null) {
        throw UndertowMessages.MESSAGES.hostHasNotBeenRegistered(host);
    }
    hostData.add(new Target(virtualHost, contextPath));
    PathMatcher<Set<H>> paths = targets.get(virtualHost);
    if(paths == null) {
        paths = new PathMatcher<>();
        targets.put(virtualHost, paths);
    }
    Set<H> hostSet = paths.getPrefixPath(contextPath);
    if(hostSet == null) {
        hostSet = new CopyOnWriteArraySet<>();
        paths.addPrefixPath(contextPath, hostSet);
    }
    hostSet.add(host);
    return this;
}
 

import java.util.concurrent.CopyOnWriteArraySet; //导入依赖的package包/类
PendingQuery(
        String dataType,
        byte[] queryMessage,
        long timeoutInMs,
        QueryCallback queryCallback) {
    mDataType = dataType;
    mQueryMessage = queryMessage;
    mTimeoutInMs = timeoutInMs;

    mRespondersById = buildRespondersById();
    mPendingResponses = new CopyOnWriteArraySet<>();
    for (long responderId : mRespondersById.keySet()) {
        mPendingResponses.add(responderId);
    }
    mResponses = new ConcurrentHashMap<>();
    mQueryCallback = queryCallback;
}
 

import java.util.concurrent.CopyOnWriteArraySet; //导入依赖的package包/类
/**
 * Add the {@link ProxyInfo} into repository for future quick access
 * 
 * @param member Distributed Member
 * @param proxyInfo Proxy Info instance
 */
protected void addProxyToRepository(DistributedMember member, ProxyInfo proxyInfo) {
  ObjectName objectName = proxyInfo.getObjectName();
  if (logger.isTraceEnabled()) {
    logger.trace("ADDED TO PROXY REPO : {}", proxyInfo.getObjectName());
  }

  objectNameIndex.put(objectName, proxyInfo);
  if (memberIndex.get(member) != null) {
    memberIndex.get(member).add(proxyInfo.getObjectName());
  } else {
    Set<ObjectName> proxyInfoSet = new CopyOnWriteArraySet<ObjectName>();
    proxyInfoSet.add(proxyInfo.getObjectName());
    memberIndex.put(member, proxyInfoSet);
  }

}
 

import java.util.concurrent.CopyOnWriteArraySet; //导入依赖的package包/类
private void addClientPartitionAdvisor(String regionFullPath, ClientPartitionAdvisor advisor) {
  if (this.cache.isClosed() || this.clientPRAdvisors == null) {
    return;
  }
  try {
    this.clientPRAdvisors.put(regionFullPath, advisor);
    if (advisor.getColocatedWith() != null) {
      String parentRegionPath = advisor.getColocatedWith();
      Set<ClientPartitionAdvisor> colocatedAdvisors =
          this.colocatedPRAdvisors.get(parentRegionPath);
      if (colocatedAdvisors == null) {
        colocatedAdvisors = new CopyOnWriteArraySet<ClientPartitionAdvisor>();
        this.colocatedPRAdvisors.put(parentRegionPath, colocatedAdvisors);
      }
      colocatedAdvisors.add(advisor);
    }
  } catch (Exception npe) {
    // ignore, shutdown case
  }

}
 

import java.util.concurrent.CopyOnWriteArraySet; //导入依赖的package包/类
public void addGatewaySenderId(String gatewaySenderId) {
  if (this.gatewaySenderIds == null) {
    this.gatewaySenderIds = new CopyOnWriteArraySet<String>();
    this.gatewaySenderIds.add(gatewaySenderId);
  } else {
    synchronized (this.gatewaySenderIds) { // TODO: revisit this
      // synchronization : added as per
      // above code
      if (this.gatewaySenderIds.contains(gatewaySenderId)) {
        throw new IllegalArgumentException(
            LocalizedStrings.AttributesFactory_GATEWAY_SENDER_ID_0_IS_ALREADY_ADDED
                .toLocalizedString(gatewaySenderId));
      }
      this.gatewaySenderIds.add(gatewaySenderId);
    }
  }
  setHasGatewaySenderIds(true);
}
 

import java.util.concurrent.CopyOnWriteArraySet; //导入依赖的package包/类
public void addAsyncEventQueueId(String asyncEventQueueId) {
  if (this.asyncEventQueueIds == null) {
    this.asyncEventQueueIds = new CopyOnWriteArraySet<String>();
    this.asyncEventQueueIds.add(asyncEventQueueId);
  } else {
    synchronized (this.asyncEventQueueIds) { // TODO: revisit this
      // synchronization : added as per
      // above code
      if (this.asyncEventQueueIds.contains(asyncEventQueueId)) {
        throw new IllegalArgumentException(
            LocalizedStrings.AttributesFactory_ASYNC_EVENT_QUEUE_ID_0_IS_ALREADY_ADDED
                .toLocalizedString(asyncEventQueueId));
      }
      this.asyncEventQueueIds.add(asyncEventQueueId);
    }
  }
  setHasAsyncEventListeners(true);
}