/*
* Copyright 2013 The Netty Project
*
* The Netty Project licenses this file to you under the Apache License,
* version 2.0 (the "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*/
package io.netty.util.concurrent;
import io.netty.util.internal.logging.
InternalLogger;
import io.netty.util.internal.logging.
InternalLoggerFactory;
import java.util.
Collection;
import java.util.
Collections;
import java.util.
Iterator;
import java.util.
List;
import java.util.concurrent.
AbstractExecutorService;
import java.util.concurrent.
Callable;
import java.util.concurrent.
RunnableFuture;
import java.util.concurrent.
TimeUnit;
/**
* Abstract base class for {@link EventExecutor} implementations.
*/
public abstract class
AbstractEventExecutor extends
AbstractExecutorService implements
EventExecutor {
private static final
InternalLogger logger =
InternalLoggerFactory.
getInstance(
AbstractEventExecutor.class);
static final long
DEFAULT_SHUTDOWN_QUIET_PERIOD = 2;
static final long
DEFAULT_SHUTDOWN_TIMEOUT = 15;
private final
EventExecutorGroup parent;
private final
Collection<
EventExecutor>
selfCollection =
Collections.<
EventExecutor>
singleton(this);
protected
AbstractEventExecutor() {
this(null);
}
protected
AbstractEventExecutor(
EventExecutorGroup parent) {
this.
parent =
parent;
}
@
Override
public
EventExecutorGroup parent() {
return
parent;
}
@
Override
public
EventExecutor next() {
return this;
}
@
Override
public boolean
inEventLoop() {
return
inEventLoop(
Thread.
currentThread());
}
@
Override
public
Iterator<
EventExecutor>
iterator() {
return
selfCollection.
iterator();
}
@
Override
public
Future<?>
shutdownGracefully() {
return
shutdownGracefully(
DEFAULT_SHUTDOWN_QUIET_PERIOD,
DEFAULT_SHUTDOWN_TIMEOUT,
TimeUnit.
SECONDS);
}
/**
* @deprecated {@link #shutdownGracefully(long, long, TimeUnit)} or {@link #shutdownGracefully()} instead.
*/
@
Override
@
Deprecated
public abstract void
shutdown();
/**
* @deprecated {@link #shutdownGracefully(long, long, TimeUnit)} or {@link #shutdownGracefully()} instead.
*/
@
Override
@
Deprecated
public
List<
Runnable>
shutdownNow() {
shutdown();
return
Collections.
emptyList();
}
@
Override
public <V>
Promise<V>
newPromise() {
return new
DefaultPromise<V>(this);
}
@
Override
public <V>
ProgressivePromise<V>
newProgressivePromise() {
return new
DefaultProgressivePromise<V>(this);
}
@
Override
public <V>
Future<V>
newSucceededFuture(V
result) {
return new
SucceededFuture<V>(this,
result);
}
@
Override
public <V>
Future<V>
newFailedFuture(
Throwable cause) {
return new
FailedFuture<V>(this,
cause);
}
@
Override
public
Future<?>
submit(
Runnable task) {
return (
Future<?>) super.submit(
task);
}
@
Override
public <T>
Future<T>
submit(
Runnable task, T
result) {
return (
Future<T>) super.submit(
task,
result);
}
@
Override
public <T>
Future<T>
submit(
Callable<T>
task) {
return (
Future<T>) super.submit(
task);
}
@
Override
protected final <T>
RunnableFuture<T>
newTaskFor(
Runnable runnable, T
value) {
return new
PromiseTask<T>(this,
runnable,
value);
}
@
Override
protected final <T>
RunnableFuture<T>
newTaskFor(
Callable<T>
callable) {
return new
PromiseTask<T>(this,
callable);
}
@
Override
public
ScheduledFuture<?>
schedule(
Runnable command, long
delay,
TimeUnit unit) {
throw new
UnsupportedOperationException();
}
@
Override
public <V>
ScheduledFuture<V>
schedule(
Callable<V>
callable, long
delay,
TimeUnit unit) {
throw new
UnsupportedOperationException();
}
@
Override
public
ScheduledFuture<?>
scheduleAtFixedRate(
Runnable command, long
initialDelay, long
period,
TimeUnit unit) {
throw new
UnsupportedOperationException();
}
@
Override
public
ScheduledFuture<?>
scheduleWithFixedDelay(
Runnable command, long
initialDelay, long
delay,
TimeUnit unit) {
throw new
UnsupportedOperationException();
}
/**
* Try to execute the given {@link Runnable} and just log if it throws a {@link Throwable}.
*/
protected static void
safeExecute(
Runnable task) {
try {
task.
run();
} catch (
Throwable t) {
logger.
warn("A task raised an exception. Task: {}",
task,
t);
}
}
}