How to approximately run two operations at the same time?

Question

I'm building a test harness in java, and trying to compare the performance and latency of two parsers. The parses munge data coming off of a live, single feed. I have no control over the feed, nor do I have a "simulated feed" for mocking data, so to compare apples to apples, I'd like to run my parses as concurrently as possible. I'm new to java and threading, so am not sure if this is the best approach. My idea was to spin 2 threads:

SomeFeed feed = new SomeFeed();

Thread thread1 = new Thread () {
  public void run () {
    parser1.parseFeed(feed);
  }
};
Thread thread2 = new Thread () {
  public void run () {
    parse2.parseFeed(feed);
  }
};
thread1.start();
thread2.start();

Will threads run this way operate roughly synchronously? Or is there a better approach?

Thanks

Answer 1

Having two threads run exactly in parallel isn't something you can really control. But if you care about starting them at the same time (almost) you can use CyclicBarrier (taken from here):

// We want to start just 2 threads at the same time, but let's control that 
// timing from the main thread. That's why we have 3 "parties" instead of 2.
final CyclicBarrier gate = new CyclicBarrier(3);

Thread t1 = new Thread(){
    public void run(){
        gate.await();
        //do stuff    
    }};
Thread t2 = new Thread(){
    public void run(){
        gate.await();
        //do stuff    
    }};

t1.start();
t2.start();

// At this point, t1 and t2 are blocking on the gate. 
// Since we gave "3" as the argument, gate is not opened yet.
// Now if we block on the gate from the main thread, it will open
// and all threads will start to do stuff!

gate.await();
System.out.println("all threads started");

This will get you the closest to starting them at the same time.

Answer 2

That is one way of doing things. Other way is implementing a Runnable interface

public class SomeFeed implements Runnable {

    public void run() {
        System.out.println("Hello from a thread!");
    }

    public static void main(String args[]) {
        (new Thread(new SomeFeed())).start();
    }

}

The new Approach is to use ThreadPool.

This is the way you could create a pool and execute your code

ExecutorService pool = Executors.newFixedThreadPool(2);

for(int i = 0; i < 2; i++){
   pool.submit(new SomeFeed());


}

Make Sure SomeFeed Implements Callable Interface.

More information can be found here

Answer 3

Regardless of you single feed problem, running the parsers concurrently is about the worst way to compare them.

Save the feed aside to become your reference data set for both tests.

You need to measure the time they took at least, while the CPU was rougly available with no interference.

And you should also do more than 1500 runs to have a fair measure of the avg time the routine takes (1500 method invocations is a threshold for hotspot JIT compilation that speeds up the code). Also, try to get the code running over 30 seconds at least, to have potential OS and disk variations interference be averaged too.

And if you notice a GC pause (always enable a gc log during benchmarks), then you have to run the test either in more memory to avoid a full gc (use -Xmx2G for example), or run the test so often that the number of full GC is fairly equal in both parsers.

Anyhow, the memory abuses and thus the GC time is also a factor of performance to judge the worst parser.