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

@SuppressWarnings("unchecked") public TaskControl(Comparator<PrioritizedTask> activeComparator,int maxThreads,ThreadFactory threadFactory,Log log){
  this.log=log;
  ApplicationIllegalArgumentException.notNull(activeComparator,"activeComparator");
  this.eligibleTasks=new PriorityBlockingQueue<PrioritizedTask>(20,activeComparator);
  this.stateChangeNotificator=new ReentrantLock();
  this.newTasks=this.stateChangeNotificator.newCondition();
  this.runningTasks=new AtomicInteger(0);
  this.threadFactory=threadFactory;
  int keepAliveTime=10;
  int corePoolSize=1;
  this.executor=new ThreadPoolExecutor(corePoolSize,Math.max(corePoolSize,maxThreads),keepAliveTime,MICROSECONDS,(BlockingQueue)this.eligibleTasks,threadFactory);
  this.stayActive=true;
}
 

@Override public boolean delete(String key,long scn) throws Exception {
  ReentrantLock l=getLock(key);
  l.lock();
  try {
    int index=getExtensionIndex(key);
    if (index >= 0) {
      extInts.set(index,null,scn);
    }
    return bufInts.delete(key,scn);
  }
  finally {
    l.unlock();
  }
}
 

public void remove(Session session){
  final ReentrantLock lock=this.lock;
  lock.lock();
  checkActiveState();
  try {
    queue.remove(session);
  }
  finally {
    lock.unlock();
  }
}
 

public ReentrantLock getLock(K key){
  ReentrantLock lock=lockMap.get(key);
  if (lock == null) {
    ReentrantLock newlock=new ReentrantLock();
    lock=lockMap.putIfAbsent(key,newlock);
    if (lock == null) {
      lock=newlock;
    }
  }
  return lock;
}
 

public boolean contains(T t){
  final ReentrantLock lock=this.lock;
  lock.lock();
  try {
    long now=System.currentTimeMillis();
    Long lastTime=objMap.get(t);
    if (lastTime != null && now - lastTime <= maxAge)     return true;
 else     return false;
  }
  finally {
    lock.unlock();
  }
}
 

public ReentrantLock getCreateLockInternal(String lockPath){
  ReentrantLock lock=localLocks.get().get(lockPath);
  if (lock != null) {
    return lock;
  }
synchronized (this) {
    lock=globalLocks.get(lockPath);
    if (lock == null) {
      lock=new ReentrantLock();
      globalLocks.put(lockPath,lock);
    }
  }
  return lock;
}
 

/** 
 * @param address
 * @return True if this channel is currently in shutdown
 */
public static boolean isShuttingdownNetworkChannel(SocketAddress address){
  ReentrantLock socketLock=getChannelLock(address);
  socketLock.lock();
  try {
    return !isAddressValid(address);
  }
  finally {
    socketLock.unlock();
  }
}
 

@Override public Object clone() throws CloneNotSupportedException {
  HttpRequestBase clone=(HttpRequestBase)super.clone();
  clone.abortLock=new ReentrantLock();
  clone.aborted=false;
  clone.releaseTrigger=null;
  clone.connRequest=null;
  clone.headergroup=(HeaderGroup)CloneUtils.clone(this.headergroup);
  clone.params=(HttpParams)CloneUtils.clone(this.params);
  return clone;
}
 

/** 
 * Create an instance with an empty map.
 */
public ConcurrentMapConfiguration(){
  map=new ConcurrentHashMap<String,Object>();
  for (int i=0; i < NUM_LOCKS; i++) {
    locks[i]=new ReentrantLock();
  }
}
 

/** 
 * Add an object to the stack and signal
 * @param object		Object to add
 * @throws InterruptedException
 */
void push(T object) throws InterruptedException {
  final ReentrantLock pushLock=this.mPushLock;
  int origSize;
  pushLock.lockInterruptibly();
  try {
synchronized (mStack) {
      origSize=mStack.size();
      mStack.push(object);
    }
  }
  finally {
    pushLock.unlock();
  }
  if (origSize == 0) {
    final ReentrantLock popLock=mPopLock;
    popLock.lock();
    try {
      mNotEmpty.signal();
    }
  finally {
      popLock.unlock();
    }
  }
}
 

ClientMessageHandler(final ExecutorService callbackService){
  Preconditions.checkNotNull(callbackService,"ExecutorService cannot be null");
  activeChannel=new AtomicReference<Channel>(null);
  this.callbackService=callbackService;
  subscribers=new ConcurrentHashMap<String,Collection<PubSubClient.MessageCallback>>();
  lock=new ReentrantLock();
}
 

public BucketsStreamingHandler(HarakiriMonitor monitor,Bucket bucket,OutputStream output){
  this.output=output;
  this.bucket=bucket;
  this.monitor=monitor;
  this.completed=new CountDownLatch(1);
  updateHandlerLock=new ReentrantLock();
}
 

/** 
 * Reentrant ????
 */
public void testLockJDK5(){
  Lock lock=new ReentrantLock();
  lock.lock();
  try {
    ticket--;
    System.out.println("The ticket: " + ticket);
  }
  finally {
    lock.unlock();
  }
}
 

public void lock(){
  if (lock != null) {
    return;
  }
  lock=new ReentrantLock();
  lock.lock();
}
 

public void testConcurrentGetRace() throws Exception {
  final ReentrantLock lock=LoggerFactoryImpl.getLock();
  lock.lock();
  final AtomicReference<Logger> loggerRef=new AtomicReference<Logger>();
  final AtomicBoolean done=new AtomicBoolean();
  Thread t=new Thread(){
    public void run(){
      Logger logger=LoggerFactory.getLogger("testConcurrentGetRace");
      loggerRef.set(logger);
      done.set(true);
    }
  }
;
  t.start();
  while (!lock.hasQueuedThread(t)) {
    Thread.sleep(1);
  }
  assertEquals(null,LoggerFactoryImpl.peekLogger("testConcurrentGetRace"));
  Logger logger=LoggerFactory.getLogger("testConcurrentGetRace");
  assertNotNull(logger);
  lock.unlock();
  while (!done.get()) {
    Thread.sleep(1);
  }
  assertSame(logger,loggerRef.get());
}
 

/** 
 * Locks a <tt>BitwiseStore</tt> to prevent it from being accessed in the middle of a <tt>Runnable</tt> operation.
 * @param name the name of the store on which to put the lock.
 * @param r the code segment to execute in lock mode.
 */
public void lock(String name,Runnable r){
synchronized (MUTEX) {
    BitwiseStoreRef ref=STORE_MAP.get(name);
    storeLocks.putIfAbsent(name,new ReentrantLock());
    ReentrantLock storeLock=storeLocks.get(name);
    while ((storeLock.isLocked() && storeLock.isHeldByCurrentThread() == false) || (ref != null && ref.isThreadExclusive() == false)) {
      if (log.isDebugEnabled()) {
        Object args[]=new Object[]{storeLock.isLocked(),storeLock.isHeldByCurrentThread(),ref != null,ref.isThreadExclusive()};
        log.debug("Waiting for lock: (isLocked [{}] && isHeldByCurrentThread() [{}]) or (ref != null [{}] && isThreadExclusive [{}])",args);
      }
      try {
        ref=null;
        MUTEX.wait(10 * 1000);
      }
 catch (      InterruptedException e) {
        throw new RuntimeException(e);
      }
      ref=STORE_MAP.get(name);
    }
    storeLock.lock();
    log.debug("Thread [{}] is holding [{}] lock(s) on store [{}]",new Object[]{Thread.currentThread().getId(),storeLock.getHoldCount(),name});
  }
  try {
    r.run();
  }
  finally {
synchronized (MUTEX) {
      storeLocks.get(name).unlock();
      MUTEX.notify();
    }
  }
}
 

/** 
 * Create a new lock for a partition, lock it, and return it. If already existing, return null.
 * @param partitionId Partition id
 * @return A newly created lock, or null if already present
 */
private Lock createLock(Integer partitionId){
  Lock lock=new ReentrantLock(true);
  lock.lock();
  if (partitionLocks.putIfAbsent(partitionId,lock) != null) {
    return null;
  }
  return lock;
}
 

public StateSynchronizer(Class<? extends Enum> states){
  lock=new ReentrantLock();
  conditions=new HashMap<Enum,Condition>();
  for (  Enum state : states.getEnumConstants()) {
    conditions.put(state,lock.newCondition());
  }
}
 

SynchronizedGraph(Graph g){
  super(g);
  elementLock=new ReentrantLock();
  synchronizedNodes=new HashMap<String,Node>();
  synchronizedEdges=new HashMap<String,Edge>();
  for (  Node n : g.getEachNode())   synchronizedNodes.put(n.getId(),new SynchronizedNode(this,n));
  for (  Edge e : g.getEachEdge())   synchronizedEdges.put(e.getId(),new SynchronizedEdge(this,e));
}
 

/** 
 * Constructor for the notification monitor.
 * @param timeout in sec
 */
public NotificationSenderMonitor(final int timeout){
  this.timeout=timeout * 1000;
  this.senderList=new ArrayList<NotificationSender>();
  this.lock=new ReentrantLock();
  this.pause=this.lock.newCondition();
  this.maxSendTrials=Config.getInt("idb","maxNotificationRetries").intValue();
  this.sendTrials=1;
}
 

/** 
 * Creates a  {@code ForkJoinPool} with the given parallelism .
 * @param parallelism the parallelism level
 * @throws IllegalArgumentException if parallelism less than orequal to zero, or greater than implementation limit
 */
public StealingPool(String name,int parallelism,int priority){
  if (parallelism <= 0 || parallelism > MAX_THREADS)   throw new IllegalArgumentException();
  this.name=name;
  this.parallelism=parallelism;
  this.priority=priority;
  this.workerLock=new ReentrantLock();
  this.termination=workerLock.newCondition();
  this.stealCount=new AtomicLong();
  this.submissionQueue=new LinkedTransferQueue<Task>();
  threads=new StealingThread[parallelism];
  for (int i=0; i < parallelism; ++i) {
    threads[i]=createWorker(i);
  }
}
 

private Lock getOrCreateLock(Thread thread,Integer file){
  ConcurrentMap<Integer,Lock> locks=perThreadDataFileLocks.get(thread);
  if (locks == null) {
    locks=new ConcurrentHashMap<Integer,Lock>();
    perThreadDataFileLocks.put(thread,locks);
  }
  Lock lock=locks.get(file);
  if (lock == null) {
    lock=new ReentrantLock();
    locks.put(file,lock);
  }
  return lock;
}
 

@Override public Object clone() throws CloneNotSupportedException {
  HttpRequestBase clone=(HttpRequestBase)super.clone();
  clone.abortLock=new ReentrantLock();
  clone.aborted=false;
  clone.cancellable=null;
  clone.headergroup=CloneUtils.cloneObject(this.headergroup);
  clone.params=CloneUtils.cloneObject(this.params);
  return clone;
}
 

public AbstractConnPool(final ConnFactory<T,C> connFactory,int defaultMaxPerRoute,int maxTotal){
  super();
  this.connFactory=Args.notNull(connFactory,"Connection factory");
  this.defaultMaxPerRoute=Args.notNegative(defaultMaxPerRoute,"Max per route value");
  this.maxTotal=Args.notNegative(maxTotal,"Max total value");
  this.lock=new ReentrantLock();
  this.routeToPool=new HashMap<T,RouteSpecificPool<T,C,E>>();
  this.leased=new HashSet<E>();
  this.available=new LinkedList<E>();
  this.pending=new LinkedList<PoolEntryFuture<E>>();
  this.maxPerRoute=new HashMap<T,Integer>();
}
 

/** 
 * any topology
 */
public ClusterFromZK(String clusterName,ZkClient zkClient,String machineId){
  this.zkClient=zkClient;
  this.taskPath="/s4/clusters/" + clusterName + "/tasks";
  this.processPath="/s4/clusters/" + clusterName + "/process";
  this.clusterName=clusterName;
  this.lock=new ReentrantLock();
  this.listeners=new ArrayList<ClusterChangeListener>();
  this.clusterRef=new AtomicReference<PhysicalCluster>();
  zkClient.subscribeChildChanges(taskPath,this);
  zkClient.subscribeChildChanges(processPath,this);
}
 

private Lock getOrCreateLock(Thread thread,Integer file){
  ConcurrentMap<Integer,Lock> locks=perThreadDataFileLocks.get(thread);
  if (locks == null) {
    locks=new ConcurrentHashMap<Integer,Lock>();
    perThreadDataFileLocks.put(thread,locks);
  }
  Lock lock=locks.get(file);
  if (lock == null) {
    lock=new ReentrantLock();
    locks.put(file,lock);
  }
  return lock;
}
 

/** 
 * Default constructor.
 * @throws SuperTypeTokenException When called without using anonymous class semantics.
 */
public SharedBuffer(){
  super();
  lockObject=new ReentrantLock();
  notFull=lockObject.newCondition();
  notEmpty=lockObject.newCondition();
}
 

/** 
 * This constructor will pass the connection spec to the super class constructor and create and install the  {@link Protocol} handler delegate instance for this {@link SyncConnection}. If you definitely need to specify the redis server version, and the protocol implementation for that version exists, you should use this constructor.  Otherwise, it is recommended that the  {@link SyncConnection#SyncConnection(ConnectionSpec)}be used. <p> This constructor will open the socket connection immediately. 
 * @param connectionSpec
 * @param redisversion
 * @throws ClientRuntimeException due to either dns (host connectivity) or any IO issues related to establishing the socket connection to the specified server.
 * @throws ProviderException if the version specified is not supported.
 */
public SyncConnection(ConnectionSpec connectionSpec) throws ClientRuntimeException, ProviderException {
  super(connectionSpec.setModality(Modality.Synchronous));
  if (spec.getConnectionFlag(Flag.RELIABLE))   lock=new ReentrantLock(false);
 else {
    lock=null;
    spec.getConnectionFlag(Flag.RELIABLE);
  }
}
 

SingletonBean(Class type,Iterable<Annotation> qualifiers,Object instance){
  super(type,Scope.SINGLETON,qualifiers);
  this.instance=instance;
  this.initialized=false;
  this.lock=new ReentrantLock();
}
 

public static void usingUnfairLock(int threadCount) throws InterruptedException {
  Lock lock=new ReentrantLock();
  Runnable[] runnables=new Runnable[threadCount];
  Thread[] threads=new Thread[threadCount];
  for (int i=0; i < threadCount; i++) {
    runnables[i]=new LockRunnable(lock);
    threads[i]=new Thread(runnables[i]);
  }
  String text="usingUnfairLock";
  execute(text,threads);
  print(text,runnables);
}
 

/** 
 * Creates a new ZkPrimitive with the correct node information.
 * @param baseNode the base node to use
 * @param zkSessionManager the session manager to use
 * @param privileges the privileges for this node.
 */
protected ZkPrimitive(String baseNode,ZkSessionManager zkSessionManager,List<ACL> privileges){
  if (baseNode == null)   throw new NullPointerException("No base node specified!");
  this.baseNode=baseNode;
  this.zkSessionManager=zkSessionManager;
  this.privileges=privileges;
  this.localLock=new ReentrantLock(true);
  condition=this.localLock.newCondition();
  signalWatcher=new SignallingWatcher(this);
  ensureNodeExists();
}
 

/** 
 * Get ServiceReference by filter with timeout.
 * @param bc       BundleContext
 * @param filter   filter
 * @param timeout  time interval to wait. If zero, the method will wait indefinately.
 * @param timeUnit time unit for the time interval
 * @return ServiceReference instance or <code>null</code>
 * @throws IllegalArgumentException If the value of timeout is negative
 * @throws NullPointerException     If <code>bc</code>, <code>filter</code> or<code>timeUnit</code> are <code>null</code>
 */
public static ServiceReference<?> getServiceReference(BundleContext bc,Filter filter,long timeout,TimeUnit timeUnit){
  final ReentrantLock lock=new ReentrantLock();
  long timeoutInMillis=timeUnit.toMillis(timeout);
  ServiceTracker tracker=new ServiceTracker(bc,filter,new ServiceTrackerCustomizerWithLock(bc,lock));
  tracker.open();
  try {
    return waitForServiceReference(tracker,timeoutInMillis,lock);
  }
 catch (  InterruptedException e) {
    return null;
  }
 finally {
    tracker.close();
  }
}
 

@Override public Object clone() throws CloneNotSupportedException {
  HttpRequestBase clone=(HttpRequestBase)super.clone();
  clone.abortLock=new ReentrantLock();
  clone.aborted=false;
  clone.releaseTrigger=null;
  clone.connRequest=null;
  clone.headergroup=(HeaderGroup)CloneUtils.clone(this.headergroup);
  clone.params=(HttpParams)CloneUtils.clone(this.params);
  return clone;
}
 

private static void doChainFilter(final FilterChain chain,final HttpServletRequest request,final HttpServletResponse response) throws IOException, ServletException {
  final HttpSession session=request.getSession();
  final Deque<ServletRequest> deque=getUsersDeque(session);
  final ReentrantLock lock=(ReentrantLock)session.getAttribute(USER_REQUEST_LOCK);
  long timeLeft=WAIT_TIME;
  try {
    if (deque.offerFirst(request)) {
      timeLeft=tryLock(request,deque,lock,timeLeft);
    }
    if (lock.isHeldByCurrentThread()) {
      chain.doFilter(request,response);
    }
 else {
      if (response instanceof HttpServletResponse) {
        LOG.warn(" -- response 409 " + (0 < timeLeft ? "(More then " + REQUEST_QUEUE_SIZE + " requests already in queue)" : "(Timeout: Waited " + WAIT_TIME + " ms)"));
        response.sendError(HttpServletResponse.SC_CONFLICT);
      }
    }
  }
  finally {
    deque.remove(request);
    if (lock.isHeldByCurrentThread()) {
      lock.unlock();
    }
  }
}
 

protected Lock getLock(String name){
synchronized (uniquenessLock) {
    Lock lk=uniquenessLock.get(name);
    if (lk == null) {
      lk=new ReentrantLock();
      uniquenessLock.put(name,lk);
    }
    return lk;
  }
}
 

@Test public void testLock() throws IOException {
  Lock inputLock=new ReentrantLock();
  Lock outputLock=new ReentrantLock();
  URL source=getClass().getResource("/iotest.txt");
  File destination=File.createTempFile("test",".txt");
  destination.deleteOnExit();
  lock(inputLock,text(source)).transferTo(lock(outputLock,Outputs.text(destination)));
}
 

private void testDeletePersonData(String ownerId,String viewerId,Set<String> fieldsToDelete,HashMap<String,String> expectedApplicationDataAfterDelete,ApplicationData applicationData){
  UserId userId=new UserId(UserId.Type.userId,VALID_USER_ID);
  Set<UserId> userIds=new HashSet<UserId>(Arrays.asList(userId));
  SecurityToken securityToken=getMockSecurityToken(ownerId,viewerId,VALID_APPLICATION_ID,VALID_MODULE_ID);
  List<Person> users=Arrays.asList(validPerson);
  GroupId groupId=new GroupId(GroupId.Type.self,"@self");
  expect(personService.getPeople(userIds,groupId,null,securityToken)).andReturn(users);
  replay(personService);
  expect(appDataRepository.getApplicationData(VALID_USER_ID,VALID_APPLICATION_ID)).andReturn(applicationData);
  Capture<ApplicationData> capturedApplicationData=new Capture<ApplicationData>();
  expect(appDataRepository.save(capture(capturedApplicationData))).andReturn(null);
  replay(appDataRepository);
  ReentrantLock lock=new ReentrantLock();
  expect(lockService.borrowLock(anyObject(String.class),anyObject(String.class))).andReturn(lock);
  lockService.returnLock(lock);
  replay(lockService);
  appDataService.deletePersonData(userId,groupId,VALID_APPLICATION_ID,fieldsToDelete,securityToken);
  ApplicationData expectedApplicationData=new ApplicationDataImpl(applicationData.getId(),applicationData.getUserId(),applicationData.getAppUrl(),expectedApplicationDataAfterDelete);
  ApplicationData actualApplicationData=capturedApplicationData.getValue();
  assertEquals(expectedApplicationData.getId(),actualApplicationData.getId());
  assertEquals(expectedApplicationData.getUserId(),actualApplicationData.getUserId());
  assertEquals(expectedApplicationData.getAppUrl(),actualApplicationData.getAppUrl());
  assertEquals(expectedApplicationData.getData(),actualApplicationData.getData());
}
 

public GenericBlockingResourcePool(ConstructionStrategy<R> constructor,int minPoolSize,int maxPoolSize){
  this.constructor=constructor;
  checkoutCounter=0;
  pool=new LinkedList<R>();
  poolLock=new ReentrantLock(true);
  poolHasResources=poolLock.newCondition();
  resizeMinimum(minPoolSize);
  resizeMaximum(maxPoolSize);
}
 

private static void acquireAccess(final String file){
  globalLock.lock();
  ReentrantLock l;
  try {
    l=openFiles.get(file);
    logger.trace(String.format("Get lock for %s (thd %x)",file,Thread.currentThread().getId()));
    if (l == null) {
      l=new ReentrantLock();
      logger.trace(" Lock created for {}",file);
      openFiles.put(file,l);
    }
 else {
      logger.trace(String.format(" Lock exists for %s (%b)",file,l.isLocked()));
    }
  }
  finally {
    globalLock.unlock();
  }
  if (l.tryLock()) {
    logger.trace(String.format(" Lock free for %s (or held by current thd %x)",file,Thread.currentThread().getId()));
  }
 else {
    logger.trace("  Wait for held lock for {}",file);
    l.lock();
    logger.trace(String.format("  Hold lock for %s (thd %x)",file,Thread.currentThread().getId()));
  }
}
 

/** 
 * Creates a new SoftHashMap with the specified retention size. <p/> The retention size (n) is the total number of most recent entries in the map that will be strongly referenced (ie 'retained') to prevent them from being eagerly garbage collected.  That is, the point of a SoftHashMap is to allow the garbage collector to remove as many entries from this map as it desires, but there will always be (n) elements retained after a GC due to the strong references. <p/> Note that in a highly concurrent environments the exact total number of strong references may differ slightly than the actual <code>retentionSize</code> value.  This number is intended to be a best-effort retention low water mark.
 * @param retentionSize the total number of most recent entries in the map that will be strongly referenced(retained), preventing them from being eagerly garbage collected by the JVM.
 */
@SuppressWarnings({"unchecked"}) public SoftHashMap(int retentionSize){
  super();
  RETENTION_SIZE=Math.max(0,retentionSize);
  queue=new ReferenceQueue<V>();
  strongReferencesLock=new ReentrantLock();
  map=new ConcurrentHashMap<K,SoftValue<V,K>>();
  strongReferences=new ConcurrentLinkedQueue<V>();
}
 

/** 
 * Creates this promise with given  {@code name}, exception  {@code chainer}, and associated  {@code lock}.
 * @param name    name of this promise
 * @param chainer {@link ExceptionChainer} that will be used for chaining exceptions
 * @param lock    lock to use
 */
public Promise(String name,ExceptionChainer<T> chainer,ReentrantLock lock){
  this.name=name;
  this.chainer=chainer;
  this.lock=lock == null ? new ReentrantLock() : lock;
  this.cond=this.lock.newCondition();
}
 

@SuppressWarnings("unchecked") public Grid2D(int sideLength,int cellCount){
  this.cellSideLength=sideLength / cellCount;
  this.cellCount=cellCount;
  cells=new HashSet[cellCount][cellCount];
  locks=new Lock[cellCount][cellCount];
  for (int i=0; i < cellCount; ++i) {
    for (int j=0; j < cellCount; ++j) {
      cells[i][j]=new HashSet<SWGObject>();
      locks[i][j]=new ReentrantLock();
    }
  }
}
 

VmPipeSession(IoService service,IoServiceListenerSupport serviceListeners,VmPipeAddress localAddress,IoHandler handler,VmPipe remoteEntry){
  super(service);
  config=new DefaultVmPipeSessionConfig();
  this.serviceListeners=serviceListeners;
  lock=new ReentrantLock();
  this.localAddress=localAddress;
  remoteAddress=serviceAddress=remoteEntry.getAddress();
  filterChain=new VmPipeFilterChain(this);
  receivedMessageQueue=new LinkedBlockingQueue<Object>();
  remoteSession=new VmPipeSession(this,remoteEntry);
}
 

protected Lock getLock(String name){
synchronized (uniquenessLock) {
    Lock lk=uniquenessLock.get(name);
    if (lk == null) {
      lk=new ReentrantLock();
      uniquenessLock.put(name,lk);
    }
    return lk;
  }
}
 

void setTransientState(ObjectContainer database,ScanAlertFactory alertFactory){
  this.database=database;
  this.alertFactory=alertFactory;
  this.lock=new ReentrantLock();
  this.eventManager=new EventListenerManager();
}
 

/** 
 * Creates a new window with the specified max window size.  This constructor enables automatic recurring tasks to be executed (such as expiration of requests).
 * @param size The maximum number of requests permitted tobe outstanding (unacknowledged) at a given time.  Must be > 0.
 * @param executor The scheduled executor service to executerecurring tasks (such as expiration of requests).
 * @param monitorInterval The number of milliseconds between executions ofmonitoring tasks.
 * @param listener A listener to send window events to
 * @param monitorThreadName The thread name we'll change to when a monitorrun is executed.  Null if no name change is required.
 */
public Window(int size,ScheduledExecutorService executor,long monitorInterval,WindowListener<K,R,P> listener,String monitorThreadName){
  if (size <= 0) {
    throw new IllegalArgumentException("size must be > 0");
  }
  this.maxSize=size;
  this.futures=new ConcurrentHashMap<K,DefaultWindowFuture<K,R,P>>(size * 2);
  this.lock=new ReentrantLock();
  this.completedCondition=this.lock.newCondition();
  this.pendingOffers=new AtomicInteger(0);
  this.pendingOffersAborted=new AtomicBoolean(false);
  this.executor=executor;
  this.monitorInterval=monitorInterval;
  this.listeners=new CopyOnWriteArrayList<UnwrappedWeakReference<WindowListener<K,R,P>>>();
  if (listener != null) {
    this.listeners.add(new UnwrappedWeakReference<WindowListener<K,R,P>>(listener));
  }
  if (this.executor != null) {
    this.monitor=new WindowMonitor(this,monitorThreadName);
    this.monitorHandle=this.executor.scheduleWithFixedDelay(this.monitor,this.monitorInterval,this.monitorInterval,TimeUnit.MILLISECONDS);
  }
 else {
    this.monitor=null;
    this.monitorHandle=null;
  }
}
 

@Test public void testDriverBlockingUntilPublicIpAvailable() throws InterruptedException {
  final Lock lock=new ReentrantLock();
  final Condition condition=lock.newCondition();
  final AtomicBoolean isBlocking=new AtomicBoolean(false);
  final JPPFLocalDriver driver=new JPPFLocalDriver(null);
  new Thread(new Runnable(){
    @Override public void run(){
      lock.lock();
      try {
        isBlocking.set(true);
        condition.signal();
      }
  finally {
        lock.unlock();
      }
      driver.getIpAddress();
    }
  }
).start();
  lock.lock();
  try {
    while (!isBlocking.get()) {
      condition.await();
      Thread.sleep(100);
    }
  }
  finally {
    lock.unlock();
  }
  nodeDeployer.addListener(driver);
  assertThat(driver.getIpAddress(),is("1.2.3.5"));
}
 

public PostIterator(PageCursor page_cursor){
  this.requesting=new ReentrantLock();
  this.page_cursor=page_cursor;
  this.post_queue=new LinkedBlockingDeque<Post>();
  if (synchronous) {
    for (    Post post : page_cursor.getNextPage()) {
      post_queue.addLast(post);
    }
  }
 else {
    if (requesting.tryLock()) {
      (new AsyncGetPage()).execute();
    }
 else {
      D.Log.v("Failed to obtain reqlock");
    }
  }
}
 

private void init(long offHeapSizeBytes){
  logger.info("	  ___   __  __ _   _                 ____  _                 ");
  logger.info("	 / _ \\ / _|/ _| | | | ___  __ _ _ __/ ___|| |_ ___  _ __ ___ ");
  logger.info("	| | | | |_| |_| |_| |/ _ \\/ _` | '_ \\___ \\| __/ _ \\| '__/ _ \\");
  logger.info("	| |_| |  _|  _|  _  |  __/ (_| | |_) |__) | || (_) | | |  __/");
  logger.info("	 \\___/|_| |_| |_| |_|\\___|\\__,_| .__/____/ \\__\\___/|_|  \\___|");
  logger.info("	                               |_|                           ");
  logger.info("default buffer size = " + DEFAULT_BUFFER_SIZE);
  logger.info("off heap size = " + offHeapSizeBytes);
  int numberOfBuffers=(int)(offHeapSizeBytes / DEFAULT_BUFFER_SIZE);
  logger.info("no of buffers = " + numberOfBuffers);
  this.bufferLocks=new ArrayList<ReentrantLock>(numberOfBuffers);
  for (int i=0; i < numberOfBuffers; i++) {
    this.bufferLocks.add(new ReentrantLock());
  }
  directMemoryCache=new DirectMemoryCache<Object,Element>(numberOfBuffers,(int)(offHeapSizeBytes / numberOfBuffers));
}
 

LazyList(AbstractDao<E,?> dao,Cursor cursor,boolean cacheEntities){
  this.dao=dao;
  this.cursor=cursor;
  size=cursor.getCount();
  if (cacheEntities) {
    entities=new ArrayList<E>(size);
    for (int i=0; i < size; i++) {
      entities.add(null);
    }
  }
 else {
    entities=null;
  }
  if (size == 0) {
    cursor.close();
  }
  lock=new ReentrantLock();
}
 

public URLGenerator(String... startFrom){
  urls=new HashSet<String>();
  stepUrls=new LinkedList<String>();
  newUrls=new HashSet<String>();
  hrefPattern=Pattern.compile(REGEX);
  mode=Mode.HOST;
  filters=new LinkedList<URLFilter>();
  directed=false;
  step=0;
  printProgress=false;
  lock=new ReentrantLock();
  declineMatchingURL("^(javascript:|mailto:|#).*");
  declineMatchingURL(".*[.](avi|tar|gz|zip|mp3|mpg|jpg|jpeg|png|ogg|flv)$");
  setUseInternalGraph(true);
  if (startFrom != null) {
    for (int i=0; i < startFrom.length; i++) {
      stepUrls.add(startFrom[i]);
    }
  }
}
 

@Override @SuppressWarnings("unchecked") public void init() throws ServiceException {
  timersSize=getServiceConfig().getInt(CONF_TIMERS_SIZE,10);
  counterLock=new ReentrantLock();
  timerLock=new ReentrantLock();
  variableLock=new ReentrantLock();
  samplerLock=new ReentrantLock();
  jvmVariables=new ConcurrentHashMap<String,VariableHolder>();
  counters=new ConcurrentHashMap<String,Map<String,AtomicLong>>();
  timers=new ConcurrentHashMap<String,Map<String,Timer>>();
  variables=new ConcurrentHashMap<String,Map<String,VariableHolder>>();
  samplers=new ConcurrentHashMap<String,Map<String,Sampler>>();
  samplersList=new ArrayList<Sampler>();
  all=new LinkedHashMap<String,Map<String,?>>();
  all.put("os-env",System.getenv());
  all.put("sys-props",(Map<String,?>)(Map)System.getProperties());
  all.put("jvm",jvmVariables);
  all.put("counters",(Map)counters);
  all.put("timers",(Map)timers);
  all.put("variables",(Map)variables);
  all.put("samplers",(Map)samplers);
  jvmVariables.put("free.memory",new VariableHolder<Long>(new Instrumentation.Variable<Long>(){
    public Long getValue(){
      return Runtime.getRuntime().freeMemory();
    }
  }
));
  jvmVariables.put("max.memory",new VariableHolder<Long>(new Instrumentation.Variable<Long>(){
    public Long getValue(){
      return Runtime.getRuntime().maxMemory();
    }
  }
));
  jvmVariables.put("total.memory",new VariableHolder<Long>(new Instrumentation.Variable<Long>(){
    public Long getValue(){
      return Runtime.getRuntime().totalMemory();
    }
  }
));
}
 

/** 
 * Creates a new instance of MultiHubsAdapter. There should always be only instance of this class. For explanation of the parameters see {@link jDCBot#jDCBot(String,String,int,int,String,String,String,String,String,int,int,boolean) jDCBot Constrcutor}.
 * @param botname
 * @param botIP
 * @param listenPort
 * @param UDP_listenPort
 * @param password
 * @param description
 * @param conn_type
 * @param email
 * @param sharesize
 * @param uploadSlots
 * @param downloadSlots
 * @param passive
 * @throws IOException 
 * @throws BotException 
 */
public MultiHubsAdapter(String botname,String botIP,int listenPort,int UDP_listenPort,String password,String description,String conn_type,String email,String sharesize,int uploadSlots,int downloadSlots,boolean passive) throws IOException, BotException {
  if (!GlobalFunctions.isUserNameValid(botname)) {
    throw new BotException(BotException.Error.INVALID_USERNAME);
  }
  _botname=botname;
  _password=password;
  _description=description;
  _conn_type=conn_type;
  _email=email;
  _sharesize=sharesize;
  _maxUploadSlots=uploadSlots;
  _maxDownloadSlots=downloadSlots;
  _botIP=botIP;
  _listenPort=listenPort;
  _passive=passive;
  _udp_port=UDP_listenPort;
  lock=new ReentrantLock();
  bots=Collections.synchronizedList(new ArrayList<jDCBot>(6));
  hubMap=Collections.synchronizedMap(new HashMap<String,Hub>(6));
  shareManager=null;
  if (_sharesize == null || _sharesize.isEmpty())   _sharesize="0";
  socketServer=new BufferedServerSocket(_listenPort);
  socketServer.setSoTimeout(60000);
  initiateUDPListening();
}
 

public AbstractDataSourceHandler(final ObjectPoolTracker poolTracker){
  this.poolTracker=poolTracker;
  this.serviceListener=new ServiceListener(){
    @Override public void dataSourceChanged(    final DataSource dataSource){
      AbstractDataSourceHandler.this.setDataSource(dataSource);
    }
  }
;
  this.dataSourceListener=new DataSourceListener(){
    @Override public void stateChanged(    final DataItemValue value){
      AbstractDataSourceHandler.this.stateChanged(value);
    }
  }
;
  final ReentrantReadWriteLock lock=new ReentrantReadWriteLock();
  this.dataSourceReadLock=lock.readLock();
  this.dataSourceWriteLock=lock.writeLock();
  this.trackerLock=new ReentrantLock();
}
 

public void notifyFailure(String messageId){
  if (!locks.containsKey(messageId))   locks.putIfAbsent(messageId,new ReentrantLock());
  Lock lock=locks.get(messageId);
  lock.lock();
  try {
    if (!redeliveryCount.containsKey(messageId)) {
      AtomicInteger failureCount=new AtomicInteger(1);
      failureCount=redeliveryCount.putIfAbsent(messageId,failureCount);
      if (failureCount != null) {
        failureCount.incrementAndGet();
      }
    }
 else {
      redeliveryCount.get(messageId).incrementAndGet();
    }
  }
  finally {
    lock.unlock();
  }
}
 

@Override public ReentrantLock getLock(){
  if (lock == null) {
    lock=new kilim.ReentrantLock();
  }
  return lock;
}
 

public void testMultiThreadedChmExtraction() throws InterruptedException {
  ExecutorService executor=Executors.newFixedThreadPool(TestParameters.NTHREADS);
  for (int i=0; i < TestParameters.NTHREADS; i++) {
    executor.execute(new Runnable(){
      public void run(){
        Lock mutex=new ReentrantLock();
        for (        String fileName : files) {
          InputStream stream=null;
          try {
            stream=TestChmExtraction.class.getResourceAsStream(fileName);
            CHMDocumentInformation chmDocInfo=CHMDocumentInformation.load(stream);
            Metadata md=new Metadata();
            mutex.lock();
            String text=chmDocInfo.getText();
            chmDocInfo.getCHMDocInformation(md);
            assertEquals(TestParameters.VP_CHM_MIME_TYPE,md.toString().trim());
            assertTrue(text.length() > 0);
          }
 catch (          Exception e) {
            e.printStackTrace();
          }
 finally {
            try {
              stream.close();
            }
 catch (            IOException e) {
              e.printStackTrace();
            }
            mutex.unlock();
          }
        }
      }
    }
);
  }
  executor.shutdown();
  while (!executor.isTerminated()) {
    Thread.sleep(500);
  }
}