Java Code Examples for java.util.concurrent.locks.ReentrantReadWriteLock

public HiveCommon(){
  final ReentrantReadWriteLock itemMapLock=new ReentrantReadWriteLock(Boolean.getBoolean("org.openscada.da.server.common.fairItemMapLock"));
  this.itemMapReadLock=itemMapLock.readLock();
  this.itemMapWriteLock=itemMapLock.writeLock();
  this.itemSubscriptionManager.setValidator(new SubscriptionValidator(){
    @Override public boolean validate(    final SubscriptionListener listener,    final Object topic){
      return validateItem(topic.toString());
    }
  }
);
}
 

/** 
 * Creates a new  {@link ExponentiallyDecayingSample}.
 * @param reservoirSize the number of samples to keep in the samplingreservoir
 * @param alpha the exponential decay factor; the higher this is, the morebiased the sample will be towards newer values
 */
public ExponentiallyDecayingSample(int reservoirSize,double alpha){
  this.values=new ConcurrentSkipListMap<Double,Long>();
  this.lock=new ReentrantReadWriteLock();
  this.alpha=alpha;
  this.reservoirSize=reservoirSize;
  clear();
}
 

public ReadWriteResourceLock getReadLock(Object resource){
  ReadWriteLock rwl=_readWriteLockMap.get(resource);
  if (rwl == null) {
    rwl=new ReentrantReadWriteLock(_isFair);
    _readWriteLockMap.put(resource,rwl);
  }
  return new ReadWriteResourceLock(resource,rwl,false);
}
 

/** 
 * Test method for created connections.
 * @throws NoSuchFieldException 
 * @throws SecurityException 
 * @throws IllegalAccessException 
 * @throws IllegalArgumentException 
 */
@Test public void testUpdateCreatedConnectionsWithException() throws SecurityException, NoSuchFieldException, IllegalArgumentException, IllegalAccessException {
  ReentrantReadWriteLock mockLock=createNiceMock(ReentrantReadWriteLock.class);
  WriteLock mockWriteLock=createNiceMock(WriteLock.class);
  Field field=testClass.getClass().getDeclaredField("statsLock");
  field.setAccessible(true);
  ReentrantReadWriteLock oldLock=(ReentrantReadWriteLock)field.get(testClass);
  field.set(testClass,mockLock);
  expect(mockLock.writeLock()).andThrow(new RuntimeException()).once().andReturn(mockWriteLock).once();
  mockWriteLock.lock();
  expectLastCall().once();
  replay(mockLock,mockWriteLock);
  try {
    testClass.updateCreatedConnections(5);
    fail("Should have thrown an exception");
  }
 catch (  Throwable t) {
  }
  verify(mockLock);
  field.set(testClass,oldLock);
}
 

public MultiFn(String name,IFn dispatchFn,Object defaultDispatchVal,IRef hierarchy){
  this.rw=new ReentrantReadWriteLock();
  this.name=name;
  this.dispatchFn=dispatchFn;
  this.defaultDispatchVal=defaultDispatchVal;
  this.methodTable=PersistentHashMap.EMPTY;
  this.methodCache=getMethodTable();
  this.preferTable=PersistentHashMap.EMPTY;
  this.hierarchy=hierarchy;
  cachedHierarchy=null;
}
 

/** 
 */
public ReconnaissanceFiltering(){
  lock=new ReentrantReadWriteLock();
  active=null;
  hidden=Collections.synchronizedSet(new HashSet<DBProgramSketch>());
  trees=Collections.synchronizedMap(new HashMap<IThread,DatabaseThreadTree>());
}
 

public DefaultParticipantDatabase(String id,ParticipantEventListener eventListener){
  this.id=id;
  this.listener=eventListener;
  this.receivers=new ArrayList<RtpParticipant>();
  this.members=new HashMap<Long,RtpParticipant>();
  this.lock=new ReentrantReadWriteLock();
  this.timeoutAfterNoPacketsReceived=TIMEOUT_AFTER_NO_PACKETS_RECEIVED;
  this.timeoutAfterByeAndNoPacketsReceived=TIMEOUT_AFTER_BYE_AND_NO_PACKETS_RECEIVED;
}
 

public DefaultHttpSession(HttpClient client,HttpClient httpsClient){
  if (client.isHttps()) {
    throw new IllegalArgumentException("HTTP client must not have SSL (HTTPS) support active");
  }
  if ((httpsClient != null) && !httpsClient.isHttps()) {
    throw new IllegalArgumentException("HTTPS client must have SSL (HTTPS) support active");
  }
  this.maxRedirects=MAX_REDIRECTS;
  this.client=client;
  this.httpsClient=httpsClient;
  ReentrantReadWriteLock rwLock=new ReentrantReadWriteLock();
  this.headerReadLock=rwLock.readLock();
  this.headerWriteLock=rwLock.writeLock();
  this.headers=new ArrayList<Map.Entry<String,String>>();
  this.handlers=new ConcurrentHashMap<Integer,ResponseCodeHandler>();
  this.addHandler(new AuthenticationResponseHandler());
  this.addHandler(new RedirectResponseHandler());
}
 

/** 
 * @see org.apache.james.mailbox.store.AbstractMailboxPathLocker#lock(org.apache.james.mailbox.MailboxSession,org.apache.james.mailbox.model.MailboxPath,boolean)
 */
protected void lock(MailboxSession session,MailboxPath path,boolean writeLock) throws MailboxException {
  ReadWriteLock lock=paths.get(path);
  if (lock == null) {
    lock=new ReentrantReadWriteLock();
    ReadWriteLock storedLock=paths.putIfAbsent(path,lock);
    if (storedLock != null) {
      lock=storedLock;
    }
  }
  getLock(lock,writeLock).lock();
}
 

public FactoryManager(){
  lock=new ReentrantReadWriteLock(true);
  factories=new HashMap<String,Object>();
  savedFactoryNames=new HashMap<String,List<String>>();
  for (  String name : FACTORY_NAMES) {
    factories.put(name,new ArrayList(4));
  }
}
 

MojiFileImpl(String key,String domain,String storageClass,TrackerFactory trackerFactory,HttpConnectionFactory httpFactory){
  this.key=key;
  this.domain=domain;
  this.storageClass=storageClass;
  this.trackerFactory=trackerFactory;
  this.httpFactory=httpFactory;
  executor=new Executor(trackerFactory);
  lock=new ReentrantReadWriteLock();
}
 

public ComponentPersistence(OSGiRuntimeService runtime){
  this.runtime=runtime;
  root=new File(Environment.getDefault().getData(),"components");
  fileLock=new ReentrantReadWriteLock();
  sysrc=runtime.getContext();
  persistedComponents=Collections.synchronizedSet(new HashSet<RegistrationInfo>());
}
 

/** 
 * This method creates, initializes and returns the backend that has to be tested. If a backend with the same meta data already exists, the old back end will be deleted.
 * @param metaData metadata that should be used when creating a back end
 * @return backend that has to be tested
 * @throws Exception in case of problems
 */
@Override protected BackEnd createBackEnd(final StorageChannelMetaData metaData) throws Exception {
  final FileBackEnd backEnd=new FileBackEnd(URLEncoder.encode(metaData.getConfigurationId(),"utf-8") + ".va",false);
  new File(backEnd.getFileName()).delete();
  backEnd.setLock(new ReentrantReadWriteLock());
  backEnd.create(metaData);
  backEnd.initialize(metaData);
  return backEnd;
}
 

public PaxLoggingServiceImpl(BundleContext context,LogReaderServiceImpl logReader,EventAdminPoster eventAdmin){
  m_bundleContext=context;
  m_logReader=logReader;
  m_eventAdmin=eventAdmin;
  m_context=new PaxContext();
  m_configLock=new ReentrantReadWriteLock();
  m_julLoggers=new LinkedList();
  configureDefaults();
}
 

/** 
 * Constructor.
 */
public ServerModel(){
  m_aliasMapping=new HashMap<String,ServletModel>();
  m_servlets=new HashSet<Servlet>();
  m_servletUrlPatterns=new HashMap<String,UrlPattern>();
  m_filterUrlPatterns=new ConcurrentHashMap<String,UrlPattern>();
  m_httpContexts=new ConcurrentHashMap<HttpContext,Bundle>();
  containerInitializers=new ConcurrentHashMap<ServletContainerInitializer,ContainerInitializerModel>();
  m_servletLock=new ReentrantReadWriteLock(true);
}
 

public Started(){
  activeServices=new HashMap<WeakReference<?>,ServiceReference>();
  staleReferences=new ReferenceQueue<Object>();
  lock=new ReentrantReadWriteLock();
  cleanupThread=new Thread(new Cleanup(),"Stale Eclipse services cleanup");
  cleanupThread.start();
}
 

/** 
 * Creates a new  {@link ExponentiallyDecayingSample}.
 * @param reservoirSize the number of samples to keep in the samplingreservoir
 * @param alpha the exponential decay factor; the higher this is, the morebiased the sample will be towards newer values
 */
public ExponentiallyDecayingSample(int reservoirSize,double alpha){
  this.values=new ConcurrentSkipListMap<Double,Long>();
  this.lock=new ReentrantReadWriteLock();
  this.alpha=alpha;
  this.reservoirSize=reservoirSize;
  clear();
}
 

/** 
 * Creates a new  {@link MemoryTokenStore}.
 */
public MemoryTokenStore(){
  this.cache=new MapMaker().softValues().expiration(120,TimeUnit.SECONDS).makeMap();
  ReadWriteLock lock=new ReentrantReadWriteLock();
  this.r=lock.readLock();
  this.w=lock.writeLock();
}
 

public DirectUpdateHandler2(SolrCore core) throws IOException {
  super(core);
  ReadWriteLock rwl=new ReentrantReadWriteLock();
  iwAccess=rwl.readLock();
  iwCommit=rwl.writeLock();
  tracker=new CommitTracker();
}
 

/** 
 * Constructor.
 * @param metadataResolver resolver used to extract basic credentials out of metadata
 * @param metadataProvider provider of the metadata used to load extended metadata for an entity
 * @param keyManager       key manager
 * @throws IllegalArgumentException thrown if the supplied provider is null
 */
public PKIXInformationResolver(MetadataCredentialResolver metadataResolver,MetadataManager metadataProvider,KeyManager keyManager){
  if (metadataProvider == null) {
    throw new IllegalArgumentException("Metadata provider may not be null");
  }
  this.metadataResolver=metadataResolver;
  this.metadata=metadataProvider;
  this.keyManager=keyManager;
  this.cache=new HashMap<MetadataCacheKey,SoftReference<Collection<PKIXValidationInformation>>>();
  this.rwlock=new ReentrantReadWriteLock();
  this.metadata.getObservers().add(new MetadataProviderObserver());
}
 

public FilteringBuffer(Buffer<E> sourceBuffer,Condition condition){
  this.indicesLock=new ReentrantReadWriteLock(true);
  this.sourceBuffer=sourceBuffer;
  this.condition=condition;
  this.filteredIndices=new ArrayList<Long>();
  this.disposed=false;
}
 

/** 
 * Construct an uninitialized Frontend.
 */
public Frontend(){
  this.volatileDirectory=null;
  this.rwlock=new ReentrantReadWriteLock(true);
  setRecursiveScopeLookups(true);
  setPrefixLookupsAllowed(true);
}
 

public Bucket(String name,String hostname,int port,int numNodes,int bucketStartPort,int numVBuckets,CouchbaseMock cluster,String password) throws IOException {
  this.cluster=cluster;
  this.name=name;
  this.numVBuckets=numVBuckets;
  this.password=password;
  datastore=new DataStore(numVBuckets);
  servers=new MemcachedServer[numNodes];
  this.configurationRwLock=new ReentrantReadWriteLock();
  BucketType type;
  if (this.getClass() == MemcacheBucket.class) {
    type=BucketType.MEMCACHE;
  }
 else   if (this.getClass() == CouchbaseBucket.class) {
    type=BucketType.COUCHBASE;
  }
 else {
    throw new FileNotFoundException("I don't know about this type...");
  }
  for (int ii=0; ii < servers.length; ii++) {
    servers[ii]=new MemcachedServer(this,hostname,(bucketStartPort == 0 ? 0 : bucketStartPort + ii),datastore);
  }
  rebalance();
}
 

public JobInAppMaster(JobId jobId,Configuration conf,AppContext appContext){
  this.applicationAttemptId=appContext.getApplicationAttemptId();
  this.jobId=jobId;
  this.jobName=conf.get(DragonJobConfig.JOB_NAME,"<missing job name>");
  this.conf=new Configuration(conf);
  this.metrics=appContext.getMetrics();
  this.clock=appContext.getClock();
  this.amInfos=appContext.getAmInfos();
  this.appContext=appContext;
  this.userName=appContext.getUser();
  this.queueName=conf.get(DragonJobConfig.QUEUE_NAME,"default");
  this.appSubmitTime=appContext.getStartTime();
  this.eventHandler=appContext.getEventHandler();
  ReadWriteLock readWriteLock=new ReentrantReadWriteLock();
  this.readLock=readWriteLock.readLock();
  this.writeLock=readWriteLock.writeLock();
  this.fsTokens=appContext.getFsTokens();
  this.jobTokenSecretManager=appContext.getJobTokenSecretManager();
  this.username=conf.get(DragonJobConfig.USER_NAME);
  this.mapNumTasks=conf.getInt(DragonJobConfig.MAP_PARALLELISM,1);
  this.reduceNumTasks=conf.getInt(DragonJobConfig.REDUCE_PARALLELISM,1);
  stateMachine=stateMachineFactory.make(this);
}
 

/** 
 * @param threads the number of threads to operate the network with; 0 means single-threaded operation,  1 starts an asynchronous thread to operate the RETE net,  >1 uses multiple RETE containers.
 */
public Network(int threads,IPatternMatcherRuntimeContext<?> context){
  super();
  this.threads=threads;
  this.context=context;
  containers=new ArrayList<ReteContainer>();
  firstContainer=(threads > 1) ? Options.firstFreeContainer : 0;
  nextContainer=firstContainer;
  if (threads > 0) {
    globalTerminationCriteria=new HashMap<ReteContainer,Long>();
    reportedClocks=new HashMap<ReteContainer,Long>();
    ReadWriteLock rwl=new ReentrantReadWriteLock();
    updateLock=rwl.readLock();
    structuralChangeLock=rwl.writeLock();
    for (int i=0; i < threads; ++i)     containers.add(new ReteContainer(this,true));
  }
 else   containers.add(new ReteContainer(this,false));
  headContainer=containers.get(0);
}
 

public OFSwitchImpl(){
  this.attributes=new ConcurrentHashMap<Object,Object>();
  this.connectedSince=new Date();
  this.transactionIdSource=new AtomicInteger();
  this.portLock=new Object();
  this.portsByNumber=new ConcurrentHashMap<Short,OFPhysicalPort>();
  this.portsByName=new ConcurrentHashMap<String,OFPhysicalPort>();
  this.connected=true;
  this.statsFutureMap=new ConcurrentHashMap<Integer,OFStatisticsFuture>();
  this.iofMsgListenersMap=new ConcurrentHashMap<Integer,IOFMessageListener>();
  this.role=null;
  this.timedCache=new TimedCache<Long>(100,5 * 1000);
  this.listenerLock=new ReentrantReadWriteLock();
  this.portBroadcastCacheHitMap=new ConcurrentHashMap<Short,Long>();
  this.pendingRoleRequests=new LinkedList<OFSwitchImpl.PendingRoleRequestEntry>();
  this.setAttribute(PROP_FASTWILDCARDS,OFMatch.OFPFW_ALL);
  this.setAttribute(PROP_SUPPORTS_OFPP_FLOOD,new Boolean(true));
  this.setAttribute(PROP_SUPPORTS_OFPP_TABLE,new Boolean(true));
}
 

/** 
 * Create an LSI and its components
 * @param scorer The scorer to use when ranking results
 * @param parser 
 * @param basePath The base path (a directory) from the which all the LSI directories will be found.   
 */
public LargeScaleIndex(Scorer scorer,IndexEngineParser parser,File baseDir,FacetingManager facetingManager){
  Preconditions.checkNotNull(scorer);
  Preconditions.checkNotNull(parser);
  Preconditions.checkNotNull(baseDir);
  this.baseDir=baseDir;
  if (!baseDir.exists() || !baseDir.isDirectory()) {
    throw new IllegalArgumentException("The basePath must be an existing directory");
  }
  File indexDir=new File(baseDir,INDEX_DIRECTORY);
  if (!indexDir.exists()) {
    logger.info("Starting with a FRESH, BRAND NEW index.");
    indexDir.mkdir();
  }
  try {
    index=new LsiIndex(parser,indexDir.getAbsolutePath(),scorer,facetingManager);
  }
 catch (  IOException e) {
    throw new IllegalArgumentException("IOException when trying to use the directory set in the index.directory property.",e);
  }
  this.scorer=scorer;
  this.indexer=new LsiIndexer(index);
  this.searcher=new LsiSearcher(index);
  this.queue=new ArrayBlockingQueue<Operation>(1000);
  this.rwl=new ReentrantReadWriteLock();
  this.r=rwl.readLock();
  this.w=rwl.writeLock();
  this.checkpoint=false;
}
 

/** 
 * Creates a synchronised map based on the Trove int object map
 * @param mapCount the number of sub-maps
 * @param initialCapacity the initial capacity of the map
 * @param loadFactor the load factor for the map
 * @param noEntryKey the key used to indicate a null key
 * @param noEntryValue the value used to indicate a null value
 */
public TSyncIntIntHashMap(int mapCount,int initialCapacity,float loadFactor,int noEntryKey,int noEntryValue){
  if (mapCount > 0x100000) {
    throw new IllegalArgumentException("Map count exceeds valid range");
  }
  mapCount=MathHelper.roundUpPow2(mapCount);
  mapMask=mapCount - 1;
  this.mapCount=mapCount;
  this.hashScramble=(mapCount << 8) + 1;
  mapArray=new TIntIntHashMap[mapCount];
  lockArray=new ReadWriteLock[mapCount];
  for (int i=0; i < mapCount; i++) {
    mapArray[i]=new TIntIntHashMap(initialCapacity / mapCount,loadFactor,noEntryKey,noEntryValue);
    lockArray[i]=new ReentrantReadWriteLock();
  }
  this.noEntryKey=noEntryKey;
  this.noEntryValue=noEntryValue;
}
 

public OFSwitchImpl(){
  this.attributes=new ConcurrentHashMap<Object,Object>();
  this.connectedSince=new Date();
  this.transactionIdSource=new AtomicInteger();
  this.ports=new ConcurrentHashMap<Short,OFPhysicalPort>();
  this.switchClusterId=null;
  this.connected=true;
  this.statsFutureMap=new ConcurrentHashMap<Integer,OFStatisticsFuture>();
  this.iofMsgListenersMap=new ConcurrentHashMap<Integer,IOFMessageListener>();
  this.role=null;
  this.timedCache=new TimedCache<Long>(100,5 * 1000);
  this.listenerLock=new ReentrantReadWriteLock();
  this.portBroadcastCacheHitMap=new ConcurrentHashMap<Short,Long>();
  this.pendingRoleRequests=new LinkedList<OFSwitchImpl.PendingRoleRequestEntry>();
  this.setAttribute(PROP_FASTWILDCARDS,(Integer)OFMatch.OFPFW_ALL);
  this.setAttribute(PROP_SUPPORTS_OFPP_FLOOD,new Boolean(true));
  this.setAttribute(PROP_SUPPORTS_OFPP_TABLE,new Boolean(true));
}
 

/** 
 * Handles the locking pattern around the INSTANCES map that's done with a ReentrantReadWriteLock.
 * @see http://permalink.gmane.org/gmane.comp.java.sesat.kernel.devel/228
 * @param < T > the type of SiteKeyedFactory that can be constructed.
 * @param site the site this factory will answer to.
 * @param instances the map of factories of type T already in existence.
 * @param instancesLock the lock used around the instances map
 * @param constructor the wrapper around the constructor used to create factories of type T.
 * @return the singleton instance of factory of type T related to the given site.
 */
protected static final <T extends AbstractSiteKeyedFactory>T instanceOf(final Site site,final Map<Site,T> instances,final ReentrantReadWriteLock instancesLock,final FactoryConstructor<T> constructor){
  try {
    instancesLock.readLock().lock();
    if (!instances.containsKey(site)) {
      instancesLock.readLock().unlock();
      instancesLock.writeLock().lock();
      try {
        if (!instances.containsKey(site)) {
          instances.put(site,constructor.construct());
        }
      }
 catch (      SiteKeyedFactoryInstantiationException e) {
        LOG.error(constructor + ERR_DOC_BUILDER_CREATION + site,e);
      }
 finally {
        instancesLock.readLock().lock();
        instancesLock.writeLock().unlock();
      }
    }
    return instances.get(site);
  }
  finally {
    instancesLock.readLock().unlock();
  }
}