Java Code Examples for java.util.concurrent.locks.LockSupport#parkUntil()

public RpcResult awaitForResponse() {
	RpcResult rpcResult = this.result.get();
	if (rpcResult != null) {
		return rpcResult;
	}
	Thread currentThread = Thread.currentThread();
	if (!awaitThread.compareAndSet(null, currentThread)) {
		throw new SoaException(RpcErrorCode.TIMEOUT, "cannot await twice", new TimeoutException());
	}
	while (result.get() == null) {

		LockSupport.parkUntil(System.currentTimeMillis() + 10000);
	}

	rpcResult = this.result.get();
	if (rpcResult == null) {
		rpcResult = RpcResult.timeout(req);
	}
	return rpcResult;
}
 

public void block(long blockSequence)
{
  long expire = System.currentTimeMillis() + _timeout;
  
  Thread thread = Thread.currentThread();
  _thread = thread;
  
  try {
    while (_readySequence < blockSequence
           && (System.currentTimeMillis() < expire)) {
      LockSupport.parkUntil(expire);
    }
  } catch (Exception e) {
    log.log(Level.FINER, e.toString(), e);
  } finally {
    _thread = null;
  }
}
 

protected void waitForNextTryTime(long nextTryTime) {
	while (true) {
		if (!isClosed() && !Thread.currentThread().isInterrupted()) {
			if (nextTryTime > m_systemClockService.now()) {
				LockSupport.parkUntil(nextTryTime);
			} else {
				break;
			}
		} else {
			return;
		}
	}
}
 

@Override
public final boolean pollWait(long sequence,
                              long timeout,
                              TimeUnit unit)
{
  if (! _queue.isEmpty()) {
    return true;
  }
  
  if (timeout <= 0) {
    return false;
  }
  

  Thread thread = Thread.currentThread();
  
  Thread oldThread = _pollThreadRef.getAndSet(thread);
  
  if (oldThread != null) {
    LockSupport.unpark(oldThread);
  }
  
  long expires = CurrentTime.getCurrentTimeActual() + unit.toMillis(timeout);
  
  while (_queue.isEmpty() && CurrentTime.getCurrentTimeActual() < expires) {
    try {
      Thread.interrupted();
      
      LockSupport.parkUntil(expires);
    } catch (Exception e) {
      
    }
  }
  
  _pollThreadRef.compareAndSet(thread, null);
  
  return ! _queue.isEmpty();
}
 

public T get(long time, TimeUnit unit)
{
  if (! _isDone) {
    long timeout = unit.toMillis(time);
    long expires = timeout + CurrentTime.getCurrentTimeActual();
    
    Thread thread = Thread.currentThread();
    
    _thread = thread;
    
    while (! _isDone && CurrentTime.getCurrentTimeActual() < expires) {
      try {
        Thread.interrupted();
        LockSupport.parkUntil(expires);
      } catch (Exception e) {
      }
    }
    
    _thread = null;
    
    if (! _isDone) {
      throw new ServiceExceptionTimeout(L.l("jamp-rpc timeout"));
    }
  }
  
  if (_exception != null) {
    throw ServiceException.createAndRethrow(_exception);
  }
  else {
    return _value;
  }
}
 

@Override
public T get(long timeout, TimeUnit unit)
    throws InterruptedException,
           ExecutionException, 
           TimeoutException
{
  long expires = System.currentTimeMillis() + unit.toMillis(timeout);

  Thread thread = Thread.currentThread();
  
  try {
    _thread = thread;
    
    while (! _isDone && System.currentTimeMillis() < expires) {
      LockSupport.parkUntil(expires);
    }
  } finally {
    _thread = null;
  }
  
  if (! _isDone) {
    throw new TimeoutException("timeout: " + timeout + " " + unit);
  }
  
  if (_exn != null) {
    throw _exn;
  }
  else {
    return _value;
  }
}
 

/**
 * Possibly triggers shutdown and tries (once) to block worker
 * when pool is (or may be) quiescent. Waits up to a duration
 * determined by number of workers.  On timeout, if ctl has not
 * changed, terminates the worker, which will in turn wake up
 * another worker to possibly repeat this process.
 *
 * @param w the calling worker
 * @return negative if w should terminate
 */
private int timedAwaitWork(WorkQueue w, long c) {
    int stat = 0;
    int scale = 1 - (short)(c >>> TC_SHIFT);
    long deadline = (((scale <= 0) ? 1 : scale) * IDLE_TIMEOUT_MS +
                     System.currentTimeMillis());
    if ((runState >= 0 || (stat = tryTerminate(false, false)) > 0) &&
        w != null && w.scanState < 0) {
        int ss; AuxState aux;
        w.parker = Thread.currentThread();
        if (w.scanState < 0)
            LockSupport.parkUntil(this, deadline);
        w.parker = null;
        if ((runState & STOP) != 0)
            stat = w.qlock = -1;         // pool terminating
        else if ((ss = w.scanState) < 0 && !Thread.interrupted() &&
                 (int)c == ss && (aux = auxState) != null && ctl == c &&
                 deadline - System.currentTimeMillis() <= TIMEOUT_SLOP_MS) {
            aux.lock();
            try {                        // pre-deregister
                WorkQueue[] ws;
                int cfg = w.config, idx = cfg & SMASK;
                long nc = ((UC_MASK & (c - TC_UNIT)) |
                           (SP_MASK & w.stackPred));
                if ((runState & STOP) == 0 &&
                    (ws = workQueues) != null &&
                    idx < ws.length && idx >= 0 && ws[idx] == w &&
                    U.compareAndSwapLong(this, CTL, c, nc)) {
                    ws[idx] = null;
                    w.config = cfg | UNREGISTERED;
                    stat = w.qlock = -1;
                }
            } finally {
                aux.unlock();
            }
        }
    }
    return stat;
}
 

void park(long millis) {
    LockSupport.parkUntil(deadline(millis));
}
 

void park(long millis) {
    LockSupport.parkUntil(theBlocker(), deadline(millis));
}
 

public T get(long timeout, TimeUnit unit)
{
  if (isDone()) {
    return getResultValue();
  }
  
  Thread thread = Thread.currentThread();
  
  //_thread = thread;
    
  long expires = unit.toMillis(timeout) + System.currentTimeMillis();
  
  while (true) {
    if (isDone()) {
      return getResultValue();
    }
    else if (_state == FutureState.ASYNC) {
      Result<Object> chain = _chain;
      Object chainValue = _chainValue;
      _chain = null;
      _chainValue = null;
      
      _state = FutureState.INIT;
        
      //_thread = null;
      
      chain.completeFuture(chainValue);
      
      /*
      if (isDone()) {
        return getResultValue();
      }
      */
      
      // _thread = thread;
    }
    else {
      if (ServiceRef.flushOutboxAndExecuteLast()) {
        // if pending messages, continue to process them
        continue;
      }
      
      // ServiceRef.flushOutbox();
      
      _thread = thread;
    
      if (_state.isParkRequired()) {
        if (expires < System.currentTimeMillis()) {
          _thread = null;
          
          throw new ServiceExceptionFutureTimeout("future timeout " + timeout + " " + unit);
        }
        
        LockSupport.parkUntil(expires);
      }
      
      _thread = null;
    }
  }
}
 

@Override
public void run()
{
  try {
    long period = _period;

    long startRun = System.currentTimeMillis();
    long startSample = startRun;

    _ticks = 0;
    
    _gcStartTime = 0;
    _gcEndTime = 0;
    
    if (_memoryBean != null) {
      _gcStartTime = _memoryBean.getGarbageCollectionTime();
    }

    while (_profileThread.get() == this) {
      long expires = startSample + _period;

      synchronized (ProfileTask.class) {
        _ticks++;

        nativeProfile(_jniProfile, _maxDepth);
      }

      long endSample = System.currentTimeMillis();

      if (endSample < expires) {
        expires = expires - expires % period;

        while (endSample < expires) {
          Thread.interrupted();
          LockSupport.parkUntil(expires);

          endSample = System.currentTimeMillis();
        }
      }

      startSample = endSample;
    }

    long time = System.currentTimeMillis() - startRun;
    long expectedTicks = time / period;
    
    if (_memoryBean != null)
      _gcEndTime = _memoryBean.getGarbageCollectionTime();
    
    log.info(this + " complete: " + time / 1000 + "s, "
             + " period=" + period + "ms,"
             + " gc-time=" + (_gcEndTime - _gcStartTime) + "ms,"
             + " missed ticks=" + (expectedTicks - _ticks)
             + String.format(" (%.2f%%),",
                             100.0 * (expectedTicks - _ticks) / _ticks)
                             + " total ticks=" + _ticks);
  } catch (Exception e) {
    log.log(Level.WARNING, e.toString(), e);
  } finally {
    _profileThread.compareAndSet(this, null);
  }
}
 

void park(long millis) {
    LockSupport.parkUntil(deadline(millis));
}
 

void park(long millis) {
    LockSupport.parkUntil(theBlocker(), deadline(millis));
}
 

private void sleepMillis(long millis) {
    long deadline = System.currentTimeMillis() + millis;
    while (System.currentTimeMillis() < deadline && !shutdown)
        LockSupport.parkUntil(cleanupSleepingHandle, deadline);
}