Use Netty Timer interface instead of HashedWheelTimer, close AsyncHttpClient#528

Author: Stephane Landelle

providers/netty/src/main/java/org/asynchttpclient/providers/netty/NettyAsyncHttpProviderConfig.java

@@ -28,7 +28,7 @@
 import io.netty.channel.Channel;
 import io.netty.channel.ChannelOption;
 import io.netty.channel.EventLoopGroup;
-import io.netty.util.HashedWheelTimer;
+import io.netty.util.Timer;
 
 import java.util.HashMap;
 import java.util.Map;
@@ -89,7 +89,7 @@ public class NettyAsyncHttpProviderConfig implements AsyncHttpProviderConfig<Str
 
     private boolean disableZeroCopy;
 
-    private HashedWheelTimer hashedWheelTimer;
+    private Timer nettyTimer;
 
     private long handshakeTimeoutInMillis;
 
@@ -235,12 +235,12 @@ public void setDisableZeroCopy(boolean disableZeroCopy) {
         this.disableZeroCopy = disableZeroCopy;
     }
 
-    public HashedWheelTimer getHashedWheelTimer() {
-        return hashedWheelTimer;
+    public Timer getNettyTimer() {
+        return nettyTimer;
     }
 
-    public void setHashedWheelTimer(HashedWheelTimer hashedWheelTimer) {
-        this.hashedWheelTimer = hashedWheelTimer;
+    public void setNettyTimer(Timer nettyTimer) {
+        this.nettyTimer = nettyTimer;
     }
 
     public long getHandshakeTimeoutInMillis() {

providers/netty/src/main/java/org/asynchttpclient/providers/netty/channel/Channels.java

@@ -55,6 +55,7 @@
 import io.netty.util.AttributeKey;
 import io.netty.util.HashedWheelTimer;
 import io.netty.util.Timeout;
+import io.netty.util.Timer;
 import io.netty.util.TimerTask;
 
 import javax.net.ssl.SSLEngine;
@@ -110,8 +111,8 @@ public boolean remove(Object o) {
         }
     };
 
-    private final boolean allowStopHashedWheelTimer;
-    private final HashedWheelTimer hashedWheelTimer;
+    private final boolean allowStopNettyTimer;
+    private final Timer nettyTimer;
     private final long handshakeTimeoutInMillis;
 
     private Processor wsProcessor;
@@ -131,9 +132,8 @@ public Channels(final AsyncHttpClientConfig config, NettyAsyncHttpProviderConfig
         eventLoopGroup = allowReleaseEventLoopGroup ? new NioEventLoopGroup() : nettyProviderConfig.getEventLoopGroup();
 
         // check if external HashedWheelTimer is defined
-        allowStopHashedWheelTimer = nettyProviderConfig.getHashedWheelTimer() == null;
-        hashedWheelTimer = allowStopHashedWheelTimer ? new HashedWheelTimer() : nettyProviderConfig.getHashedWheelTimer();
-        hashedWheelTimer.start();
+        allowStopNettyTimer = nettyProviderConfig.getNettyTimer() == null;
+        nettyTimer = allowStopNettyTimer ? newNettyTimer() : nettyProviderConfig.getNettyTimer();
         handshakeTimeoutInMillis = nettyProviderConfig.getHandshakeTimeoutInMillis();
 
         if (!(eventLoopGroup instanceof NioEventLoopGroup))
@@ -147,7 +147,7 @@ public Channels(final AsyncHttpClientConfig config, NettyAsyncHttpProviderConfig
         ChannelPool cp = nettyProviderConfig.getChannelPool();
         if (cp == null) {
             if (config.getAllowPoolingConnection()) {
-                cp = new DefaultChannelPool(config, hashedWheelTimer);
+                cp = new DefaultChannelPool(config, nettyTimer);
             } else {
                 cp = new NonChannelPool();
             }
@@ -195,6 +195,12 @@ public Channels(final AsyncHttpClientConfig config, NettyAsyncHttpProviderConfig
         secureWebSocketBootstrap.option(ChannelOption.CONNECT_TIMEOUT_MILLIS, timeOut);
     }
 
+    private Timer newNettyTimer() {
+        HashedWheelTimer nettyTimer = new HashedWheelTimer();
+        nettyTimer.start();
+        return nettyTimer;
+    }
+
     private SSLEngine createSSLEngine() throws IOException, GeneralSecurityException {
         SSLEngine sslEngine = config.getSSLEngineFactory().newSSLEngine();
         if (sslEngine == null) {
@@ -299,8 +305,8 @@ public void close() {
         if (allowReleaseEventLoopGroup)
             eventLoopGroup.shutdownGracefully();
 
-        if (allowStopHashedWheelTimer)
-            hashedWheelTimer.stop();
+        if (allowStopNettyTimer)
+            nettyTimer.stop();
     }
 
     /**
@@ -475,7 +481,7 @@ public void abort(NettyResponseFuture<?> future, Throwable t) {
     }
 
     public Timeout newTimeoutInMs(TimerTask task, long delayInMs) {
-        return hashedWheelTimer.newTimeout(task, delayInMs, TimeUnit.MILLISECONDS);
+        return nettyTimer.newTimeout(task, delayInMs, TimeUnit.MILLISECONDS);
     }
 
     public static SslHandler getSslHandler(Channel channel) {

providers/netty/src/main/java/org/asynchttpclient/providers/netty/channel/DefaultChannelPool.java

@@ -21,8 +21,8 @@
 import org.slf4j.LoggerFactory;
 
 import io.netty.channel.Channel;
-import io.netty.util.HashedWheelTimer;
 import io.netty.util.Timeout;
+import io.netty.util.Timer;
 import io.netty.util.TimerTask;
 
 import java.util.ArrayList;
@@ -43,20 +43,20 @@ public class DefaultChannelPool implements ChannelPool {
     private final ConcurrentHashMap<Channel, IdleChannel> channel2IdleChannel = new ConcurrentHashMap<Channel, IdleChannel>();
     private final ConcurrentHashMap<Channel, Long> channel2CreationDate = new ConcurrentHashMap<Channel, Long>();
     private final AtomicBoolean closed = new AtomicBoolean(false);
-    private final HashedWheelTimer hashedWheelTimer;
+    private final Timer nettyTimer;
     private final boolean sslConnectionPoolEnabled;
     private final int maxTotalConnections;
     private final int maxConnectionPerHost;
     private final int maxConnectionLifeTimeInMs;
     private final long maxIdleTime;
 
-    public DefaultChannelPool(AsyncHttpClientConfig config, HashedWheelTimer hashedWheelTimer) {
+    public DefaultChannelPool(AsyncHttpClientConfig config, Timer nettyTimer) {
         this(config.getMaxTotalConnections(),//
                 config.getMaxConnectionPerHost(),//
                 config.getIdleConnectionInPoolTimeoutInMs(),//
                 config.isSslConnectionPoolEnabled(),//
                 config.getMaxConnectionLifeTimeInMs(),//
-                hashedWheelTimer);
+                nettyTimer);
     }
 
     public DefaultChannelPool(//
@@ -65,18 +65,18 @@ public DefaultChannelPool(//
             long maxIdleTime,//
             boolean sslConnectionPoolEnabled,//
             int maxConnectionLifeTimeInMs,//
-            HashedWheelTimer hashedWheelTimer) {
+            Timer nettyTimer) {
         this.maxTotalConnections = maxTotalConnections;
         this.maxConnectionPerHost = maxConnectionPerHost;
         this.sslConnectionPoolEnabled = sslConnectionPoolEnabled;
         this.maxIdleTime = maxIdleTime;
         this.maxConnectionLifeTimeInMs = maxConnectionLifeTimeInMs;
-        this.hashedWheelTimer = hashedWheelTimer;
+        this.nettyTimer = nettyTimer;
         scheduleNewIdleChannelDetector(new IdleChannelDetector());
     }
 
     private void scheduleNewIdleChannelDetector(TimerTask task) {
-        this.hashedWheelTimer.newTimeout(task, maxIdleTime, TimeUnit.MILLISECONDS);
+        nettyTimer.newTimeout(task, maxIdleTime, TimeUnit.MILLISECONDS);
     }
 
     private static class IdleChannel {