Java Timeout類代碼示例

import io.netty.util.Timeout; //導入依賴的package包/類
@Override
protected void awaitResultAsync(final RemoteInvocationOptions optionsCopy, final RemotePromise<Object> result,
        final RemoteServiceRequest request, final String responseName) {
    if (!optionsCopy.isResultExpected()) {
        return;
    }
    
    Long startTime = 0L;
    if (request != null && request.getArgs() != null && request.getArgs().length > 3) {
        startTime = (Long)request.getArgs()[3];
    }
    long delay = startTime - System.currentTimeMillis();
    if (delay > 0) {
        commandExecutor.getConnectionManager().newTimeout(new TimerTask() {
            @Override
            public void run(Timeout timeout) throws Exception {
                ScheduledTasksService.super.awaitResultAsync(optionsCopy, result, request, responseName);
            }
        }, delay, TimeUnit.MILLISECONDS);
    } else {
        super.awaitResultAsync(optionsCopy, result, request, responseName);
    }
}
 

import io.netty.util.Timeout; //導入依賴的package包/類
private synchronized void scheduleReconnect()
{
	if (_stop)
		return;
	if (_timeout != null)
		return;
	Constants.ahessianLogger.warn("channel closed wait to reconnect ...");
	_retryCounter++;
	long retryIntervall = Math.min(RECONNECT_DELAY * _retryCounter,
			MAX_RECONNECT_DELAY);
	_timeout = _timer.newTimeout(new TimerTask()
	{
		public void run(Timeout timeout) throws Exception
		{
			_timeout = null;
			connect(_bootstrap.getBootstrap());

		}
	}, retryIntervall, TimeUnit.MILLISECONDS);
}
 

import io.netty.util.Timeout; //導入依賴的package包/類
public HeartbeatHandlerInbound(final String name, final Timer timer,
		final long timeout)
{
	_name = name;
	final TimerTask task = new TimerTask()
	{
		public void run(Timeout nTimeout) throws Exception
		{
			if (((getLastCalled() + timeout) <= System.currentTimeMillis())
					&& isConnected())
				try
				{
					_action.timedOut(_ctx);
				}
				catch (Exception e)
				{
					Constants.ahessianLogger.warn("", e);
				}
		}

	};
	_intervalTimer = new IntervalTimer(timer, task, timeout);
}
 

import io.netty.util.Timeout; //導入依賴的package包/類
public T poll(int group)
{
	LinkedList<T> q = _queues[group];
	T result = null;
	if (q != null)
	{
		result = q.poll();
		if (result != null)
		{
			Timeout timer = _timers.remove(result);
			if (timer != null)
				timer.cancel();
		}
	}
	return result;
}
 

import io.netty.util.Timeout; //導入依賴的package包/類
@Override
public void run(Timeout timeout) throws Exception {
    Connection connection = this.connection;

    if (connection == null || !connection.isConnected()) {
        Logs.HB.info("heartbeat timeout times={}, connection disconnected, conn={}", timeoutTimes, connection);
        return;
    }

    if (connection.isReadTimeout()) {
        if (++timeoutTimes > CC.mp.core.max_hb_timeout_times) {
            connection.close();
            Logs.HB.warn("client heartbeat timeout times={}, do close conn={}", timeoutTimes, connection);
            return;
        } else {
            Logs.HB.info("client heartbeat timeout times={}, connection={}", timeoutTimes, connection);
        }
    } else {
        timeoutTimes = 0;
    }
    startTimeout();
}
 

import io.netty.util.Timeout; //導入依賴的package包/類
@Override
public void run(Timeout timeout) throws Exception {
    if (timeout.isCancelled()) {
        return;
    }
    if (log.isDebugEnabled()) {
        log.debug("[{}] [{}] Batching the messages from the batch container from timer thread", topic,
                producerName);
    }
    // semaphore acquired when message was enqueued to container
    synchronized (ProducerImpl.this) {
        batchMessageAndSend();
    }
    // schedule the next batch message task
    client.timer().newTimeout(this, conf.getBatchingMaxPublishDelayMs(), TimeUnit.MILLISECONDS);
}
 

import io.netty.util.Timeout; //導入依賴的package包/類
public void start(PulsarClientImpl client, ConsumerBase consumerBase, long ackTimeoutMillis) {
    this.stop();
    timeout = client.timer().newTimeout(new TimerTask() {
        @Override
        public void run(Timeout t) throws Exception {
            if (isAckTimeout()) {
                log.warn("[{}] {} messages have timed-out", consumerBase, oldOpenSet.size());
                Set<MessageIdImpl> messageIds = new HashSet<>();
                oldOpenSet.forEach(messageIds::add);
                oldOpenSet.clear();
                consumerBase.redeliverUnacknowledgedMessages(messageIds);
            }
            toggle();
            timeout = client.timer().newTimeout(this, ackTimeoutMillis, TimeUnit.MILLISECONDS);
        }
    }, ackTimeoutMillis, TimeUnit.MILLISECONDS);
}
 

import io.netty.util.Timeout; //導入依賴的package包/類
/**
 * {@inheritDoc}
 * @see io.netty.util.Timer#newTimeout(io.netty.util.TimerTask, long, java.util.concurrent.TimeUnit)
 */
@Override
public Timeout newTimeout(final TimerTask task, final long delay, final TimeUnit unit) {
	final WrappedTimeout[] t = new WrappedTimeout[1];
	t[0] = new WrappedTimeout(timer.newTimeout(new TimerTask(){
		@Override
		public void run(final Timeout timeout) throws Exception {
			try {
				task.run(t[0]);
			} finally {
				pendingTimeouts.decrementAndGet();
				timeouts.increment();
			}				
		}			
	}, delay, unit));
	return t[0];
}
 

import io.netty.util.Timeout; //導入依賴的package包/類
private void scheduleRequestTimeout(RequestHeader requestHeader) {
    UInteger requestHandle = requestHeader.getRequestHandle();

    long timeoutHint = requestHeader.getTimeoutHint() != null ?
        requestHeader.getTimeoutHint().longValue() : DEFAULT_TIMEOUT_MS;

    Timeout timeout = wheelTimer.newTimeout(t -> {
        if (timeouts.remove(requestHandle) != null && !t.isCancelled()) {
            CompletableFuture<UaResponseMessage> f = pending.remove(requestHandle);
            if (f != null) {
                String message = "request timed out after " + timeoutHint + "ms";
                f.completeExceptionally(new UaException(StatusCodes.Bad_Timeout, message));
            }
        }
    }, timeoutHint, TimeUnit.MILLISECONDS);

    timeouts.put(requestHandle, timeout);
}
 

import io.netty.util.Timeout; //導入依賴的package包/類
@Override
public void run(Timeout timeout) throws Exception {
    log.debug("Timeout occured for Session {}", id);
    //Notify the listener that timeout has occured
    final SessionValue session = sessionManager.getSession(id);

    //Do not proceed if the session is null
    if (session == null) {
        log.error("could not find session value for id {}. Registry Size : {}", id, sessionManager.getSessionEntries().size());
        return;
    }

    //Check first if the promise has been completed
    if (session.getClientPromise() != null && !session.getClientPromise().isDone() && !session.getClientPromise().isCancelled() && !timeout.isCancelled()) {
        //Send a ReadTimeoutException to the client
        session.getClientPromise().completeExceptionally(new ReadTimeoutException(id, String.format("Timeout occured for '%s' Started: %f seconds ago", id, ((double) Duration.ofMillis(System.currentTimeMillis() - session.getTimeRegistered()).toMillis() / 1000.0))));
    }
}
 

import io.netty.util.Timeout; //導入依賴的package包/類
/**
 * Intentional private local constructor
 * @param key the request key
 * @param request the request object
 * @param window the window
 * @param timeoutMillis the time after which this future will be cancelled
 * @param timer the timer used to implement the timeout functionality
 */
private TimedDeferredRequest(final K key,
                             final R request,
                             final Window<K, R, D> window,
                             final Timer timer,
                             final long timeoutMillis) {
    super(key, request, window);
    this.timeout = checkNotNull(timer).newTimeout(new TimerTask() {
                                                      @Override
                                                      public void run(Timeout timerTask) throws Exception {
                                                          window.fail(checkNotNull(key),
                                                                      new TimeoutException("The operation timed out (Window full)"));
                                                      }
                                                  },
                                                  timeoutMillis,
                                                  TimeUnit.MILLISECONDS);
}
 

import io.netty.util.Timeout; //導入依賴的package包/類
private void newRefreshTask() {
    if (refreshTaskMap.containsKey(getName())) {
        return;
    }

    Timeout task = commandExecutor.getConnectionManager().newTimeout(new TimerTask() {
        @Override
        public void run(Timeout timeout) throws Exception {
            expire(internalLockLeaseTime, TimeUnit.MILLISECONDS);
            refreshTaskMap.remove(getName());
            newRefreshTask(); // reschedule itself
        }
    }, internalLockLeaseTime / 3, TimeUnit.MILLISECONDS);

    if (refreshTaskMap.putIfAbsent(getName(), task) != null) {
        task.cancel();
    }
}
 

import io.netty.util.Timeout; //導入依賴的package包/類
@Override
public void itemsReceived(CpfItem[] items) {
    int connectionId = ((ConnectedAddressItem) items[0]).getConnectionId();
    ByteBuf buffer = ((ConnectedDataItemResponse) items[1]).getData();

    int sequenceNumber = buffer.readShort();
    ByteBuf data = buffer.readSlice(buffer.readableBytes()).retain();

    Timeout timeout = timeouts.remove(sequenceNumber);
    if (timeout != null) timeout.cancel();

    CompletableFuture<ByteBuf> future = pending.remove(sequenceNumber);

    if (future != null) {
        future.complete(data);
    } else {
        ReferenceCountUtil.release(data);
    }

    ReferenceCountUtil.release(buffer);
}
 

import io.netty.util.Timeout; //導入依賴的package包/類
@SuppressWarnings("unchecked")
private PendingRequest(CompletableFuture<T> future, Timeout timeout) {
    this.timeout = timeout;

    promise.whenComplete((r, ex) -> {
        if (r != null) {
            try {
                future.complete((T) r);
            } catch (ClassCastException e) {
                future.completeExceptionally(e);
            }
        } else {
            future.completeExceptionally(ex);
        }
    });
}
 

import io.netty.util.Timeout; //導入依賴的package包/類
/**
     * {@inheritDoc}
     * <br/>
     * Sends for each remote participant a report containing the status
     * of this session participant. 
     */
    @Override
    public void run(Timeout timeout) throws Exception {
        if (!this.running.get()) {
            return;
        }
        // send status update per remote participant
        final long currentSsrc = this.localParticipant.getSsrc();
        final SourceDescriptionPacket sdesPacket = buildSdesPacket(currentSsrc);
        this.participantDatabase.doWithReceivers(new ParticipantOperation() {
            @Override
            public void doWithParticipant(RtpParticipant participant) throws Exception {
                AbstractReportPacket report = buildReportPacket(currentSsrc, participant);
                // TODO: really to all other participants?
                // i would use:
//                writeToControl(new CompoundControlPacket(report, sdesPacket), participant.getControlDestination());
                internalSendControl(new CompoundControlPacket(report, sdesPacket));
            }
        });

        if (!this.running.get()) {
            return;
        }
        this.timer.newTimeout(this, this.updatePeriodicRtcpSendInterval(), TimeUnit.SECONDS);
    }