geode-issues mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From "ASF GitHub Bot (JIRA)" <j...@apache.org>
Subject [jira] [Commented] (GEODE-3416) Reduce blocking for SocketCloser.asyncClose
Date Tue, 15 Aug 2017 00:28:00 GMT

    [ https://issues.apache.org/jira/browse/GEODE-3416?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=16126672#comment-16126672
] 

ASF GitHub Bot commented on GEODE-3416:
---------------------------------------

Github user WireBaron commented on a diff in the pull request:

    https://github.com/apache/geode/pull/702#discussion_r133094233
  
    --- Diff: geode-core/src/main/java/org/apache/geode/internal/net/SocketCloser.java ---
    @@ -96,46 +99,55 @@ public int getMaxThreads() {
         return this.asyncClosePoolMaxThreads;
       }
     
    -  private ThreadPoolExecutor getAsyncThreadExecutor(String address) {
    -    synchronized (asyncCloseExecutors) {
    -      ThreadPoolExecutor pool = asyncCloseExecutors.get(address);
    -      if (pool == null) {
    -        final ThreadGroup tg = LoggingThreadGroup.createThreadGroup("Socket asyncClose",
logger);
    -        ThreadFactory tf = new ThreadFactory() {
    -          public Thread newThread(final Runnable command) {
    -            Thread thread = new Thread(tg, command);
    -            thread.setDaemon(true);
    -            return thread;
    -          }
    -        };
    -        BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<Runnable>();
    -        pool = new ThreadPoolExecutor(this.asyncClosePoolMaxThreads, this.asyncClosePoolMaxThreads,
    -            this.asyncClosePoolKeepAliveSeconds, TimeUnit.SECONDS, workQueue, tf);
    -        pool.allowCoreThreadTimeOut(true);
    -        asyncCloseExecutors.put(address, pool);
    +  private ExecutorService getAsyncThreadExecutor(String address) {
    +    ExecutorService executorService = asyncCloseExecutors.get(address);
    +    if (executorService == null) {
    +      // To be used for pre-1.8 jdk releases.
    +      // createThreadPool();
    +
    +      executorService = Executors.newWorkStealingPool(asyncClosePoolMaxThreads);
    +
    +      ExecutorService previousThreadPoolExecutor =
    +          asyncCloseExecutors.putIfAbsent(address, executorService);
    +
    +      if (previousThreadPoolExecutor != null) {
    +        executorService.shutdownNow();
    +        return previousThreadPoolExecutor;
           }
    -      return pool;
         }
    +    return executorService;
    +  }
    +
    +  /**
    +   * @deprecated this method is to be used for pre 1.8 jdk.
    +   */
    +  @Deprecated
    +  private void createThreadPool() {
    +    ExecutorService executorService;
    +    final ThreadGroup threadGroup =
    +        LoggingThreadGroup.createThreadGroup("Socket asyncClose", logger);
    +    ThreadFactory threadFactory = new ThreadFactory() {
    +      public Thread newThread(final Runnable command) {
    +        Thread thread = new Thread(threadGroup, command);
    +        thread.setDaemon(true);
    +        return thread;
    +      }
    +    };
    +
    +    executorService = new ThreadPoolExecutor(asyncClosePoolMaxThreads, asyncClosePoolMaxThreads,
    +        asyncCloseWaitTime, asyncCloseWaitUnits, new LinkedBlockingQueue<>(), threadFactory);
       }
     
       /**
        * Call this method if you know all the resources in the closer for the given address
are no
        * longer needed. Currently a thread pool is kept for each address and if you know
that an address
        * no longer needs its pool then you should call this method.
        */
    -  public void releaseResourcesForAddress(String address) {
    -    synchronized (asyncCloseExecutors) {
    -      ThreadPoolExecutor pool = asyncCloseExecutors.get(address);
    -      if (pool != null) {
    -        pool.shutdown();
    -        asyncCloseExecutors.remove(address);
    -      }
    -    }
    -  }
     
    -  private boolean isClosed() {
    -    synchronized (asyncCloseExecutors) {
    -      return this.closed;
    +  public void releaseResourcesForAddress(String address) {
    +    ExecutorService executorService = asyncCloseExecutors.remove(address);
    +    if (executorService != null) {
    +      executorService.shutdown();
    --- End diff --
    
    Is this call (excutorService.shutdown) reentrant?


> Reduce blocking for SocketCloser.asyncClose 
> --------------------------------------------
>
>                 Key: GEODE-3416
>                 URL: https://issues.apache.org/jira/browse/GEODE-3416
>             Project: Geode
>          Issue Type: Bug
>          Components: client/server
>    Affects Versions: 1.1.0, 1.1.1, 1.2.0, 1.2.1
>            Reporter: Udo Kohlmeyer
>            Assignee: Udo Kohlmeyer
>             Fix For: 1.3.0
>
>
> In the SocketCloser.asyncClose method, there is a synchronization block around at HashMap.
This synchronization will cause an effective single-threaded processing capability when closing
sockets. this effect becomes more evident with a high number of clients.



--
This message was sent by Atlassian JIRA
(v6.4.14#64029)

Mime
View raw message