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 17:47:00 GMT

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

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

Github user kohlmu-pivotal commented on a diff in the pull request:

    https://github.com/apache/geode/pull/702#discussion_r133255222
  
    --- 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 --
    
    Correct and agreed. When the cache closes, I imagine SocketCloser.close() is called. Which
means the closing of any socket post that would be done in-line. 
    I don't know what the expected behavior is supposed to be, for the closing of the sockets
when that cache is closing. But you are correct that it could mean that the closing of the
socket could be holding up the shutting down of the cache.



> 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