From 42abb6df3ae4f7763b61c4d749995d4d582f13b2 Mon Sep 17 00:00:00 2001 From: Trustin Lee Date: Wed, 30 May 2012 16:19:22 -0700 Subject: [PATCH] QueueFactory cleanup - Really attempt to create a queue to determine LTQ can be initialized in runtime, and cache the result - Remove unnecessary Class parameter in createQueue() - Remove unused createQueue(Collection) --- .../handler/codec/http/HttpClientCodec.java | 2 +- .../codec/http/HttpContentEncoder.java | 2 +- .../io/netty/util/internal/QueueFactory.java | 61 +++++++++++-------- .../netty/channel/SingleThreadEventLoop.java | 2 +- .../channel/socket/oio/OioEventLoop.java | 3 +- 5 files changed, 38 insertions(+), 32 deletions(-) diff --git a/codec-http/src/main/java/io/netty/handler/codec/http/HttpClientCodec.java b/codec-http/src/main/java/io/netty/handler/codec/http/HttpClientCodec.java index ed4bfbec70..3d98ecc48c 100644 --- a/codec-http/src/main/java/io/netty/handler/codec/http/HttpClientCodec.java +++ b/codec-http/src/main/java/io/netty/handler/codec/http/HttpClientCodec.java @@ -46,7 +46,7 @@ import java.util.concurrent.atomic.AtomicLong; public class HttpClientCodec extends CombinedChannelHandler { /** A queue that is used for correlating a request and a response. */ - final Queue queue = QueueFactory.createQueue(HttpMethod.class); + final Queue queue = QueueFactory.createQueue(); /** If true, decoding stops (i.e. pass-through) */ volatile boolean done; diff --git a/codec-http/src/main/java/io/netty/handler/codec/http/HttpContentEncoder.java b/codec-http/src/main/java/io/netty/handler/codec/http/HttpContentEncoder.java index f758aeccb7..96bf0d0fea 100644 --- a/codec-http/src/main/java/io/netty/handler/codec/http/HttpContentEncoder.java +++ b/codec-http/src/main/java/io/netty/handler/codec/http/HttpContentEncoder.java @@ -49,7 +49,7 @@ import java.util.Queue; */ public abstract class HttpContentEncoder extends MessageToMessageCodec { - private final Queue acceptEncodingQueue = QueueFactory.createQueue(String.class); + private final Queue acceptEncodingQueue = QueueFactory.createQueue(); private volatile EncoderEmbedder encoder; /** diff --git a/common/src/main/java/io/netty/util/internal/QueueFactory.java b/common/src/main/java/io/netty/util/internal/QueueFactory.java index 28d4589b09..5b11469ab4 100644 --- a/common/src/main/java/io/netty/util/internal/QueueFactory.java +++ b/common/src/main/java/io/netty/util/internal/QueueFactory.java @@ -15,7 +15,9 @@ */ package io.netty.util.internal; -import java.util.Collection; +import io.netty.logging.InternalLogger; +import io.netty.logging.InternalLoggerFactory; + import java.util.concurrent.BlockingQueue; /** @@ -23,40 +25,45 @@ import java.util.concurrent.BlockingQueue; * instance for the running JVM. */ public final class QueueFactory { - - private static final boolean useUnsafe = DetectionUtil.hasUnsafe(); - - private QueueFactory() { - // only use static methods! + + private static final InternalLogger logger = + InternalLoggerFactory.getInstance(QueueFactory.class); + + private static final boolean USE_LTQ; + + static { + boolean useLTQ = false; + try { + if (DetectionUtil.hasUnsafe()) { + new LinkedTransferQueue(); + useLTQ = true; + } + logger.debug( + "No access to the Unsafe - using " + + LegacyLinkedTransferQueue.class.getSimpleName() + " instead."); + } catch (Throwable t) { + logger.debug( + "Failed to initialize a " + LinkedTransferQueue.class.getSimpleName() + " - " + + "using " + LegacyLinkedTransferQueue.class.getSimpleName() + " instead.", t); + } + + USE_LTQ = useLTQ; } - - + /** - * Create a new unbound {@link BlockingQueue} - * - * @param itemClass the {@link Class} type which will be used as {@link BlockingQueue} items + * Create a new unbound {@link BlockingQueue} + * * @return queue the {@link BlockingQueue} implementation */ - public static BlockingQueue createQueue(Class itemClass) { - if (useUnsafe) { + public static BlockingQueue createQueue() { + if (USE_LTQ) { return new LinkedTransferQueue(); } else { return new LegacyLinkedTransferQueue(); } } - - /** - * Create a new unbound {@link BlockingQueue} - * - * @param collection the collection which should get copied to the newly created {@link BlockingQueue} - * @param itemClass the {@link Class} type which will be used as {@link BlockingQueue} items - * @return queue the {@link BlockingQueue} implementation - */ - public static BlockingQueue createQueue(Collection collection, Class itemClass) { - if (useUnsafe) { - return new LinkedTransferQueue(collection); - } else { - return new LegacyLinkedTransferQueue(collection); - } + + private QueueFactory() { + // only use static methods! } } diff --git a/transport/src/main/java/io/netty/channel/SingleThreadEventLoop.java b/transport/src/main/java/io/netty/channel/SingleThreadEventLoop.java index fa1ccd67ea..5e6c9f22b3 100644 --- a/transport/src/main/java/io/netty/channel/SingleThreadEventLoop.java +++ b/transport/src/main/java/io/netty/channel/SingleThreadEventLoop.java @@ -50,7 +50,7 @@ public abstract class SingleThreadEventLoop extends AbstractExecutorService impl } // Fields for event loop - private final BlockingQueue taskQueue = QueueFactory.createQueue(Runnable.class); + private final BlockingQueue taskQueue = QueueFactory.createQueue(); private final Thread thread; private final Object stateLock = new Object(); private final Semaphore threadLock = new Semaphore(0); diff --git a/transport/src/main/java/io/netty/channel/socket/oio/OioEventLoop.java b/transport/src/main/java/io/netty/channel/socket/oio/OioEventLoop.java index b72927472d..75a46ac2b1 100644 --- a/transport/src/main/java/io/netty/channel/socket/oio/OioEventLoop.java +++ b/transport/src/main/java/io/netty/channel/socket/oio/OioEventLoop.java @@ -29,8 +29,7 @@ public class OioEventLoop implements EventLoop { final ThreadFactory threadFactory; final Set activeChildren = Collections.newSetFromMap( new ConcurrentHashMap()); - final Queue idleChildren = - QueueFactory.createQueue(OioChildEventLoop.class); + final Queue idleChildren = QueueFactory.createQueue(); private final ChannelException tooManyChannels; public OioEventLoop() {