test/gc/stress/TestStressG1Humongous.java

@@ -19,11 +19,11 @@
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */
 
- /*
+/*
  * @test TestStressG1Humongous
  * @key gc
  * @key stress
  * @summary Stress G1 by humongous allocations in situation near OOM
  * @requires vm.gc.G1

@@ -40,12 +40,10 @@
 
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Collections;
 import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
 import java.util.concurrent.atomic.AtomicInteger;
 
 public class TestStressG1Humongous {
 
     // Timeout in seconds

@@ -54,37 +52,36 @@
     private static final int REGION_SIZE = Integer.getInteger("regionsize", 1) * 1024 * 1024;
     private static final int HUMONGOUS_SIZE = (int) (REGION_SIZE * Double.parseDouble(System.getProperty("humongoussize", "1.5")));
     private static final int NUMBER_OF_FREE_REGIONS = 2;
 
     private volatile boolean isRunning;
-    private final ExecutorService threadExecutor;
+    private final Thread[] threads;
     private final AtomicInteger alocatedObjectsCount;
     private CountDownLatch countDownLatch;
     public static final List<Object> GARBAGE = Collections.synchronizedList(new ArrayList<>());
 
     public static void main(String[] args) throws InterruptedException {
         new TestStressG1Humongous().run();
     }
 
     public TestStressG1Humongous() {
         isRunning = true;
-        threadExecutor = Executors.newFixedThreadPool(THREAD_COUNT + 1);
+        threads = new Thread[THREAD_COUNT];
         alocatedObjectsCount = new AtomicInteger(0);
     }
 
     private void run() throws InterruptedException {
-        threadExecutor.submit(new Timer());
+        new Thread(new Timer()).start();
         int checkedAmountOfHObjects = getExpectedAmountOfObjects();
         while (isRunning()) {
             countDownLatch = new CountDownLatch(THREAD_COUNT);
             startAllocationThreads(checkedAmountOfHObjects);
             countDownLatch.await();
             GARBAGE.clear();
             System.out.println("Allocated " + alocatedObjectsCount.get() + " objects.");
             alocatedObjectsCount.set(0);
         }
-        threadExecutor.shutdown();
         System.out.println("Done!");
     }
 
     /**
      * Tries to fill available memory with humongous objects to get expected amount.

@@ -108,13 +105,16 @@
      */
     private void startAllocationThreads(int totalObjects) {
         int objectsPerThread = totalObjects / THREAD_COUNT;
         int objectsForLastThread = objectsPerThread + totalObjects % THREAD_COUNT;
         for (int i = 0; i < THREAD_COUNT - 1; ++i) {
-            threadExecutor.submit(new AllocationThread(countDownLatch, objectsPerThread, alocatedObjectsCount));
+            threads[i] = new Thread(new AllocationThread(countDownLatch, objectsPerThread, alocatedObjectsCount));
+        }
+        threads[THREAD_COUNT - 1] = new Thread(new AllocationThread(countDownLatch, objectsForLastThread, alocatedObjectsCount));
+        for (int i = 0; i < THREAD_COUNT; ++i) {
+            threads[i].start();
         }
-        threadExecutor.submit(new AllocationThread(countDownLatch, objectsForLastThread, alocatedObjectsCount));
     }
 
     /**
      * Creates a humongous object of the predefined size.
      */