[incubator-iotdb] 01/03: modify mem table pool

[lt...@apache.org]

This is an automated email from the ASF dual-hosted git repository.

lta pushed a commit to branch feature_async_close_tsfile
in repository https://gitbox.apache.org/repos/asf/incubator-iotdb.git

commit b0db03a0616d0c3d27d718bd221b4450e574410e
Author: lta <li...@163.com>
AuthorDate: Mon Jun 17 21:42:09 2019 +0800

    modify mem table pool
---
 .../iotdb/db/engine/memtable/MemTablePool.java     | 58 ++++++++++------------
 1 file changed, 26 insertions(+), 32 deletions(-)

diff --git a/iotdb/src/main/java/org/apache/iotdb/db/engine/memtable/MemTablePool.java b/iotdb/src/main/java/org/apache/iotdb/db/engine/memtable/MemTablePool.java
index a1b8e7c..e50be7f 100644
--- a/iotdb/src/main/java/org/apache/iotdb/db/engine/memtable/MemTablePool.java
+++ b/iotdb/src/main/java/org/apache/iotdb/db/engine/memtable/MemTablePool.java
@@ -1,22 +1,23 @@
 package org.apache.iotdb.db.engine.memtable;
 
-import java.util.Stack;
-import org.apache.iotdb.tsfile.common.constant.SystemConstant;
+import java.util.ArrayDeque;
+import java.util.Deque;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 public class MemTablePool {
   private static final Logger LOGGER = LoggerFactory.getLogger(MemTablePool.class);
 
-  private Stack<IMemTable> emptyMemTables;
+  private Deque<IMemTable> emptyMemTables;
   // >= number of storage group * 2
   private int capacity = 20;
   private int size = 0;
+  private static final int WAIT_TIME = 2000;
 
   private static final MemTablePool INSTANCE = new MemTablePool();
 
-  public MemTablePool() {
-    emptyMemTables = new Stack<>();
+  private MemTablePool() {
+    emptyMemTables = new ArrayDeque<>();
   }
 
   public IMemTable getEmptyMemTable(Object applier) {
@@ -26,44 +27,37 @@ public class MemTablePool {
         LOGGER.info("generated a new memtable for {}, system memtable size: {}, stack size: {}",
             applier, size, emptyMemTables.size());
         return new PrimitiveMemTable();
-      } else if (!emptyMemTables.isEmpty()){
-        LOGGER.info("system memtable size: {}, stack size: {}, then get a memtable from stack for {}",
-            size, emptyMemTables.size(), applier);
+      } else if (!emptyMemTables.isEmpty()) {
+        LOGGER
+            .info("system memtable size: {}, stack size: {}, then get a memtable from stack for {}",
+                size, emptyMemTables.size(), applier);
         return emptyMemTables.pop();
       }
-    }
-    // wait until some one has released a memtable
-    long waitStartTime = System.currentTimeMillis();
-    long lastPrintIdx = 0;
-    while (true) {
-      if(!emptyMemTables.isEmpty()) {
-        synchronized (emptyMemTables) {
-          if (!emptyMemTables.isEmpty()){
-            LOGGER.info("system memtable size: {}, stack size: {}, then get a memtable from stack for {}",
-                size, emptyMemTables.size(), applier);
-            return emptyMemTables.pop();
-          }
+
+      // wait until some one has released a memtable
+      int waitCount = 1;
+      while (true) {
+        if (!emptyMemTables.isEmpty()) {
+          LOGGER.info(
+              "system memtable size: {}, stack size: {}, then get a memtable from stack for {}",
+              size, emptyMemTables.size(), applier);
+          return emptyMemTables.pop();
         }
-      }
-      try {
-        Thread.sleep(20);
-      } catch (InterruptedException e) {
-        Thread.currentThread().interrupt();
-        LOGGER.error("Unexpected interruption", e);
-      }
-      long waitedTime = System.currentTimeMillis() - waitStartTime;
-      if (waitedTime / 2000 > lastPrintIdx) {
-        lastPrintIdx = waitedTime / 2000;
-        LOGGER.info("{} has waited for a memtable for {}ms", applier, waitedTime);
+        try {
+          emptyMemTables.wait(WAIT_TIME);
+        } catch (InterruptedException e) {
+          LOGGER.error("{} fails to wait fot memtables {}, continue to wait", applier, e);
+        }
+        LOGGER.info("{} has waited for a memtable for {}ms", applier, waitCount * WAIT_TIME);
       }
     }
   }
 
-
   public void release(IMemTable memTable) {
     synchronized (emptyMemTables) {
       memTable.clear();
       emptyMemTables.push(memTable);
+      emptyMemTables.notify();
       LOGGER.info("a memtable returned, stack size {}", emptyMemTables.size());
     }
   }