How to use method of org.jmock.lib.concurrent.Blitzer class

1package org.jmock.lib.concurrent;
2
3import static java.util.concurrent.TimeUnit.MILLISECONDS;
4
5import java.util.concurrent.CountDownLatch;
6import java.util.concurrent.ExecutorService;
7import java.util.concurrent.Executors;
8import java.util.concurrent.TimeoutException;
9
10
11/**
12 * A class that "blitzes" an object by calling it many times, from multiple
13 * threads. Used for stress-testing synchronisation.
14 * 
15 * @author nat
16 */
17public class Blitzer {
18    /**
19     * The default number of threads to run concurrently.
20     */
21    public static final int DEFAULT_THREAD_COUNT = 2;
22
23    private final ExecutorService executorService;
24    private final int actionCount;
25    
26    public Blitzer(int actionCount) {
27        this(actionCount, DEFAULT_THREAD_COUNT);
28    }
29    
30    public Blitzer(int actionCount, int threadCount) {
31        this.actionCount = actionCount;
32        this.executorService = Executors.newFixedThreadPool(threadCount);
33    }
34    
35    public Blitzer(int actionCount, ExecutorService executorService) {
36        this.actionCount = actionCount;
37        this.executorService = executorService;;
38    }
39    
40    public int totalActionCount() {
41        return actionCount;
42    }
43
44    public void blitz(final Runnable action) throws InterruptedException {
45        spawnThreads(action).await();
46    }
47
48    public void blitz(long timeoutMs, final Runnable action) throws InterruptedException, TimeoutException {
49        if (!spawnThreads(action).await(timeoutMs, MILLISECONDS)) {
50            throw new TimeoutException("timed out waiting for blitzed actions to complete successfully");
51        }
52    }
53
54    private CountDownLatch spawnThreads(final Runnable action) {
55        final CountDownLatch finished = new CountDownLatch(actionCount);
56        
57        for (int i = 0; i < actionCount; i++) {
58            executorService.execute(new Runnable() {
59                public void run() {
60                    try {
61                        action.run();
62                    }
63                    finally {
64                        finished.countDown();
65                    }
66                }
67            });
68        }
69        
70        return finished;
71    }
72
73    public void shutdown() {
74        executorService.shutdown();
75    }
76}
77

Source: Blitzer.java

package org.jmock.lib.concurrent;

import static java.util.concurrent.TimeUnit.MILLISECONDS;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeoutException;


/**
 * A class that "blitzes" an object by calling it many times, from multiple
 * threads. Used for stress-testing synchronisation.
 * 
 * @author nat
 */
public class Blitzer {
    /**
     * The default number of threads to run concurrently.
     */
    public static final int DEFAULT_THREAD_COUNT = 2;

    private final ExecutorService executorService;
    private final int actionCount;
    
    public Blitzer(int actionCount) {
        this(actionCount, DEFAULT_THREAD_COUNT);
    }
    
    public Blitzer(int actionCount, int threadCount) {
        this.actionCount = actionCount;
        this.executorService = Executors.newFixedThreadPool(threadCount);
    }
    
    public Blitzer(int actionCount, ExecutorService executorService) {
        this.actionCount = actionCount;
        this.executorService = executorService;;
    }
    
    public int totalActionCount() {
        return actionCount;
    }

    public void blitz(final Runnable action) throws InterruptedException {
        spawnThreads(action).await();
    }

    public void blitz(long timeoutMs, final Runnable action) throws InterruptedException, TimeoutException {
        if (!spawnThreads(action).await(timeoutMs, MILLISECONDS)) {
            throw new TimeoutException("timed out waiting for blitzed actions to complete successfully");
        }
    }

    private CountDownLatch spawnThreads(final Runnable action) {
        final CountDownLatch finished = new CountDownLatch(actionCount);
        
        for (int i = 0; i < actionCount; i++) {
            executorService.execute(new Runnable() {
                public void run() {
                    try {
                        action.run();
                    }
                    finally {
                        finished.countDown();
                    }
                }
            });
        }
        
        return finished;
    }

    public void shutdown() {
        executorService.shutdown();
    }
}