com.gemstone.gemfire.internal.ScheduledThreadPoolExecutorWithKeepAliveJUnitTest Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of gemfire-junit Show documentation
Show all versions of gemfire-junit Show documentation
SnappyData store based off Pivotal GemFireXD
/*
* Copyright (c) 2010-2015 Pivotal Software, Inc. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you
* may not use this file except in compliance with the License. You
* may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
* implied. See the License for the specific language governing
* permissions and limitations under the License. See accompanying
* LICENSE file.
*/
package com.gemstone.gemfire.internal;
import junit.framework.TestCase;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @author dsmith
*
*/
public class ScheduledThreadPoolExecutorWithKeepAliveJUnitTest extends TestCase {
public ScheduledThreadPoolExecutorWithKeepAliveJUnitTest() {
super("ScheduledThreadPoolExecutorWithKeepAlive");
}
ScheduledThreadPoolExecutorWithKeepAlive ex;
public void tearDown() throws Exception {
ex.setContinueExistingPeriodicTasksAfterShutdownPolicy(false);
ex.setExecuteExistingDelayedTasksAfterShutdownPolicy(false);
ex.shutdownNow();
assertTrue(ex.awaitTermination(10, TimeUnit.SECONDS));
}
public void testFuture() throws InterruptedException, ExecutionException {
ex = new ScheduledThreadPoolExecutorWithKeepAlive(
5, 60, TimeUnit.SECONDS, Executors.defaultThreadFactory());
final AtomicBoolean done = new AtomicBoolean();
Future f = ex.submit(new Runnable() {
public void run() {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
fail("interrupted");
}
done.set(true);
}
});
f.get();
assertTrue("Task did not complete", done.get());
f = ex.submit(new Callable() {
public Object call() {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
fail("interrupted");
}
return Boolean.TRUE;
}
});
assertTrue("Task did not complete", ((Boolean)f.get()).booleanValue());
assertEquals(2, ex.getLargestPoolSize());
}
public void testConcurrentExecutionAndExpiration() throws InterruptedException, ExecutionException {
ex = new ScheduledThreadPoolExecutorWithKeepAlive(
50, 1, TimeUnit.SECONDS, Executors.defaultThreadFactory());
Runnable waitForABit = new Runnable() {
public void run() {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
fail("interrupted");
}
}
};
Future[] futures = new Future[50];
for(int i = 0; i < 50; i++) {
futures[i] = ex.submit(waitForABit);
}
long start = System.nanoTime();
for(int i = 0; i < 50; i++) {
futures[i].get();
}
long end = System.nanoTime();
assertTrue("Tasks executed in parallel", TimeUnit.NANOSECONDS.toSeconds(end - start) < 50);
assertEquals(50, ex.getLargestPoolSize());
//now make sure we expire back down.
Thread.sleep(5000);
assertEquals(1, ex.getPoolSize());
}
public void testConcurrentRepeatedTasks() throws InterruptedException, ExecutionException {
ex = new ScheduledThreadPoolExecutorWithKeepAlive(
50, 1, TimeUnit.SECONDS, Executors.defaultThreadFactory());
final AtomicInteger counter = new AtomicInteger();
Runnable waitForABit = new Runnable() {
public void run() {
try {
counter.incrementAndGet();
Thread.sleep(1000);
} catch (InterruptedException e) {
fail("interrupted");
}
}
};
Future[] futures = new Future[50];
for(int i = 0; i < 50; i++) {
futures[i] = ex.scheduleAtFixedRate(waitForABit,0, 1, TimeUnit.SECONDS);
}
Thread.sleep(10000);
for(int i = 0; i < 50; i++) {
futures[i].cancel(true);
}
assertTrue("Tasks did not execute in parallel. Expected more than 300 executions, got " + counter.get(), counter.get() > 300);
assertEquals(50, ex.getLargestPoolSize());
//now make sure we expire back down.
Thread.sleep(5000);
assertEquals(1, ex.getPoolSize());
}
/**
* time, in nanoseconds, that we should tolerate as slop
* (evidently needed for windows)
*/
private static final long SLOP = TimeUnit.MILLISECONDS.toNanos(20);
public void testDelayedExcecution() throws InterruptedException, ExecutionException {
ex = new ScheduledThreadPoolExecutorWithKeepAlive(
50, 1, TimeUnit.SECONDS, Executors.defaultThreadFactory());
long start = System.nanoTime();
Future f = ex.schedule(new Runnable() { public void run() {}}, 10, TimeUnit.SECONDS);
f.get();
long end = System.nanoTime();
assertTrue("Execution was not delayed 10 seconds, only " + (end - start),
TimeUnit.SECONDS.toNanos(10) <= end - start + SLOP);
}
public void testRepeatedExecution() throws InterruptedException {
ex = new ScheduledThreadPoolExecutorWithKeepAlive(
50, 1, TimeUnit.SECONDS, Executors.defaultThreadFactory());
final AtomicInteger counter = new AtomicInteger();
Runnable run = new Runnable() {
public void run() {
counter.incrementAndGet();
}
};
ScheduledFuture f = ex.scheduleAtFixedRate(run, 0, 1, TimeUnit.SECONDS);
Thread.sleep(5000);
f.cancel(true);
assertTrue("Task was not executed repeatedly", counter.get() > 1);
int oldValue = counter.get();
Thread.sleep(5000);
assertEquals("Task was not cancelled", oldValue, counter.get());
}
public void testShutdown() throws InterruptedException {
ex = new ScheduledThreadPoolExecutorWithKeepAlive(
50, 1, TimeUnit.SECONDS, Executors.defaultThreadFactory());
ex.schedule(new Runnable() {
public void run() {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
fail("interrupted");
}
}
}, 2, TimeUnit.SECONDS);
ex.shutdown();
long start = System.nanoTime();
assertTrue(ex.awaitTermination(10, TimeUnit.SECONDS));
long elapsed = System.nanoTime() - start;
assertTrue("Shutdown did not wait to task to complete. Only waited "
+ TimeUnit.NANOSECONDS.toMillis(elapsed),
TimeUnit.SECONDS.toNanos(4) < elapsed + SLOP);
}
public void testShutdown2() throws InterruptedException {
ex = new ScheduledThreadPoolExecutorWithKeepAlive(
50, 1, TimeUnit.SECONDS, Executors.defaultThreadFactory());
ex.submit(new Runnable() {
public void run() {
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
fail("interrupted");
}
}
});
//give it a chance to get in the worker pool
Thread.sleep(500);
ex.shutdown();
long start = System.nanoTime();
assertTrue(ex.awaitTermination(10, TimeUnit.SECONDS));
long elapsed = System.nanoTime() - start;
assertTrue("Shutdown did not wait to task to complete. Only waited "
+ TimeUnit.NANOSECONDS.toMillis(elapsed), TimeUnit.SECONDS.toNanos(2) < elapsed);
}
public void testShutdownNow() throws InterruptedException {
ex = new ScheduledThreadPoolExecutorWithKeepAlive(
50, 1, TimeUnit.SECONDS, Executors.defaultThreadFactory());
ex.schedule(new Runnable() {
public void run() {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
fail("interrupted");
}
}
}, 2, TimeUnit.SECONDS);
ex.shutdownNow();
long start = System.nanoTime();
assertTrue(ex.awaitTermination(1, TimeUnit.SECONDS));
long elapsed = System.nanoTime() - start;
assertTrue("ShutdownNow should not have waited. Waited "
+ TimeUnit.NANOSECONDS.toMillis(elapsed), TimeUnit.SECONDS.toNanos(2) > elapsed);
}
public void testShutdownNow2() throws InterruptedException {
ex = new ScheduledThreadPoolExecutorWithKeepAlive(
50, 1, TimeUnit.SECONDS, Executors.defaultThreadFactory());
ex.submit(new Runnable() {
public void run() {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
fail("interrupted");
}
}
});
//give it a chance to get in the worker pool.
Thread.sleep(500);
ex.shutdownNow();
long start = System.nanoTime();
assertTrue(ex.awaitTermination(1, TimeUnit.SECONDS));
long elapsed = System.nanoTime() - start;
assertTrue("ShutdownNow should not have waited. Waited "
+ TimeUnit.NANOSECONDS.toMillis(elapsed), TimeUnit.SECONDS.toNanos(2) > elapsed);
}
public void testShutdownDelayedTasks() throws InterruptedException {
ex = new ScheduledThreadPoolExecutorWithKeepAlive(
50, 1, TimeUnit.SECONDS, Executors.defaultThreadFactory());
ex.setExecuteExistingDelayedTasksAfterShutdownPolicy(false);
ex.schedule(new Runnable() {
public void run() {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
fail("interrupted");
}
}
}, 5000, TimeUnit.MILLISECONDS);
ex.shutdown();
long start = System.nanoTime();
assertTrue(ex.awaitTermination(30, TimeUnit.SECONDS));
long elapsed = System.nanoTime() - start;
assertTrue("Shutdown should not have waited. Waited "
+ TimeUnit.NANOSECONDS.toMillis(elapsed), TimeUnit.SECONDS.toNanos(2) > elapsed);
}
public void testAllWorkersActive() throws InterruptedException {
ex = new ScheduledThreadPoolExecutorWithKeepAlive(
6, 1, TimeUnit.SECONDS, Executors.defaultThreadFactory());
final AtomicInteger counter = new AtomicInteger();
long start = System.nanoTime();
for(int i = 0; i < 100; i++) {
ex.submit(new Runnable() {
public void run() {
try {
Thread.sleep(500);
counter.incrementAndGet();
} catch (InterruptedException e) {
fail("interrupted");
}
}
});
}
long elapsed = System.nanoTime() - start;
assertTrue("calling ex.submit blocked the caller", TimeUnit.SECONDS.toNanos(1) > elapsed);
Thread.sleep(20 * 500 + 1000);
assertEquals(100, counter.get());
assertEquals(6, ex.getMaximumPoolSize());
}
}