Java Timeout.cancel方法代碼示例

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包/類
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包/類
public void stop()
{
	_stop = true;
	Timeout timeout = _timeout;
	_timeout = null;
	timeout.cancel();
}
 

import io.netty.util.Timeout; //導入方法依賴的package包/類
private void handleSession(ChannelHandlerContext ctx, Session session,
		HandlerList pipeline)
{
	_hasSession = true;
	session.setClosed(false);

	// if we have a session timeout set, cancel it.
	Timeout timeOut = session.removeTimeout();
	if (timeOut != null)
		timeOut.cancel();

	if (pipeline.hasChannel())
	{
		Constants.ahessianLogger.warn(ctx.channel()
				+ " session already attached -> close connection");
		pipeline.close();
	}

	// now that we have a session extend the pipeline
	pipeline.mixin(ctx);
	ctx.channel().attr(SESSION).set(session);
	_channel = ctx.channel();
	// first send session and wait until it has been transmitted
	ctx.writeAndFlush(Unpooled.wrappedBuffer(session.getId().getBytes()))
			.awaitUninterruptibly();
	// only then inform the mixin pipeline that we are connected
	ctx.fireChannelActive();
}
 

import io.netty.util.Timeout; //導入方法依賴的package包/類
private void cancelTimeout() {
	final Timeout timeout = this.timeout;
	if (timeout != null) {
		timeout.cancel();
		this.timeout = null;
	}
}
 

import io.netty.util.Timeout; //導入方法依賴的package包/類
public void cancelPeriodicTransmissionTimeout(Timeout timeout) {
    if (timeout != null) {
        synchronized (timeout) {
            if (!timeout.isExpired()) {
                timeout.cancel();
            }
        }
    }
}
 

import io.netty.util.Timeout; //導入方法依賴的package包/類
public void secureChannelIssuedOrRenewed(ServerSecureChannel secureChannel, long lifetimeMillis) {
    long channelId = secureChannel.getChannelId();

    /*
     * Cancel any existing timeouts and start a new one.
     */
    Timeout timeout = timeouts.remove(channelId);
    boolean cancelled = (timeout == null || timeout.cancel());

    if (cancelled) {
        timeout = wheelTimer.newTimeout(t ->
            closeSecureChannel(secureChannel), lifetimeMillis, TimeUnit.MILLISECONDS);

        timeouts.put(channelId, timeout);

        /*
         * If this is a reconnect there might be responses queued, so drain those.
         */
        Channel channel = secureChannel.attr(BoundChannelKey).get();

        if (channel != null) {
            List<ServiceResponse> responses = responseQueues.removeAll(channelId);

            responses.forEach(channel::write);
            channel.flush();
        }
    }
}
 

import io.netty.util.Timeout; //導入方法依賴的package包/類
@Override
public PingTxnStatus pingTxn(final String scope, final String stream, final UUID txnId, int version, long lease) {

    if (!this.isRunning()) {
        return PingTxnStatus.newBuilder().setStatus(PingTxnStatus.Status.DISCONNECTED).build();
    }

    final String key = getKey(scope, stream, txnId);
    Preconditions.checkState(map.containsKey(key), "Stream not found in the map");

    final TxnData txnData = map.get(key);

    if (txnData == null) {
        throw new IllegalStateException(String.format("Transaction %s not added to timerWheelTimeoutService", txnId));
    }

    if (lease > maxLeaseValue || lease > txnData.getScaleGracePeriod()) {
        return PingTxnStatus.newBuilder().setStatus(PingTxnStatus.Status.LEASE_TOO_LARGE).build();
    }

    if (lease + System.currentTimeMillis() > txnData.getMaxExecutionTimeExpiry()) {
        return PingTxnStatus.newBuilder().setStatus(PingTxnStatus.Status.MAX_EXECUTION_TIME_EXCEEDED).build();
    } else {
        Timeout timeout = txnData.getTimeout();
        boolean cancelSucceeded = timeout.cancel();
        if (cancelSucceeded) {
            TxnData newTxnData = txnData.updateLease(scope, stream, txnId, version, lease);
            map.replace(key, txnData, newTxnData);
            return PingTxnStatus.newBuilder().setStatus(PingTxnStatus.Status.OK).build();
        } else {
            // Cancellation may fail because timeout task (1) may be scheduled for execution, or (2) is executing.
            throw new IllegalStateException(String.format("Failed updating timeout for transaction %s", txnId));
        }
    }

}
 

import io.netty.util.Timeout; //導入方法依賴的package包/類
@Override
public <T> FutureListener<T> createReleaseWriteListener(final int slot,
                                final RedisConnection conn, final Timeout timeout) {
    return new FutureListener<T>() {
        @Override
        public void operationComplete(io.netty.util.concurrent.Future<T> future) throws Exception {
            shutdownLatch.release();
            timeout.cancel();
            releaseWrite(slot, conn);
        }
    };
}
 

import io.netty.util.Timeout; //導入方法依賴的package包/類
@Override
public <T> FutureListener<T> createReleaseReadListener(final int slot,
                                final RedisConnection conn, final Timeout timeout) {
    return new FutureListener<T>() {
        @Override
        public void operationComplete(io.netty.util.concurrent.Future<T> future) throws Exception {
            shutdownLatch.release();
            timeout.cancel();
            releaseRead(slot, conn);
        }
    };
}
 

import io.netty.util.Timeout; //導入方法依賴的package包/類
/**
 * Stop refresh timer
 * @return true if timer was stopped successfully
 */
private void stopRefreshTask() {
    Timeout task = refreshTaskMap.remove(getName());
    if (task != null) {
        task.cancel();
    }
}
 

import io.netty.util.Timeout; //導入方法依賴的package包/類
private void receiveResponse(UaResponseMessage response) {
    ResponseHeader header = response.getResponseHeader();
    UInteger requestHandle = header.getRequestHandle();

    CompletableFuture<UaResponseMessage> future = pending.remove(requestHandle);

    if (future != null) {
        if (header.getServiceResult().isGood()) {
            future.complete(response);
        } else {
            ServiceFault serviceFault;

            if (response instanceof ServiceFault) {
                serviceFault = (ServiceFault) response;
            } else {
                serviceFault = new ServiceFault(header);
            }

            future.completeExceptionally(new UaServiceFaultException(serviceFault));
        }

        Timeout timeout = timeouts.remove(requestHandle);
        if (timeout != null) timeout.cancel();
    } else {
        logger.warn("Received {} for unknown requestHandle: {}",
                response.getClass().getSimpleName(), requestHandle);
    }
}
 

import io.netty.util.Timeout; //導入方法依賴的package包/類
public void secureChannelIssuedOrRenewed(ServerSecureChannel secureChannel, long lifetimeMillis) {
    long channelId = secureChannel.getChannelId();

    /*
     * Cancel any existing timeouts and start a new one.
     */
    Timeout timeout = timeouts.remove(channelId);
    boolean cancelled = (timeout == null || timeout.cancel());

    if (cancelled) {
        timeout = wheelTimer.newTimeout(t ->
                closeSecureChannel(secureChannel), lifetimeMillis, TimeUnit.MILLISECONDS);

        timeouts.put(channelId, timeout);

        /*
         * If this is a reconnect there might be responses queued, so drain those.
         */
        Channel channel = secureChannel.attr(BoundChannelKey).get();

        if (channel != null) {
            List<ServiceResponse> responses = responseQueues.removeAll(channelId);

            responses.forEach(channel::write);
            channel.flush();
        }
    }
}
 

import io.netty.util.Timeout; //導入方法依賴的package包/類
void cancelExpirationRenewal() {
    Timeout task = expirationRenewalMap.remove(getEntryName());
    if (task != null) {
        task.cancel();
    }
}