使用多线程提高性能

Question

I'm writing a Java program to solve this problem:

I have a balanced tree (namely, a TreeSet in Java) containing values. I have "Task" objects that will do either of the two things: try to find a value in the tree, or add a value to the tree. I will have a list of these "Task" objects (I used a LinkedList in Java) and I create threads to read and remove the tasks from this list one by one and perform their required action (ie, find or add a value in the tree). I have created a synchronized "remove" method for my task list (which simply calls the underlying LinkedList's "remove" method). I have also defined the "add" method of the tree to be synchronized... (I don't know if it's necessary for it to be synchronized or not, but I assume it is).

How can I improve the performance of this program when using multiple threads? Right now, if I use a single thread, the time is better than when I use multiple threads.

This is the run method of my TaskRunner class, my threads are objects of this class and it implements Runnable , tasks is the list containing tasks and tree is my TreeSet passed to this object in the constructor:

Task task;
int action;     // '0' for search, '1' for add
int value;      // Value to be used for searching or adding

while (!tasks.isEmpty()) {
    try { task = tasks.remove(); }
    catch (NoSuchElementException ex) { break; }

    action = task.getAction();
    value = task.getValue();

    if (action == 0)
        boolean found = tree.contains(value);
    else
        tree.add(value);
}

Also, my tree inherits from TreeSet<Integer> in Java and I have defined its add method as synchronized :

public synchronized boolean add(Integer e) {
    return super.add(e);
}

And my task list inherits from LinkedList<Task> and its remove method:

public synchronized Task remove() {
    return super.remove();
}

Answer 1

If your task class implements Runnable interface, you can use ThreadPool to process the tasks. Here is an example:

public class TreeSetTaskExample {

public static class Task implements Runnable {

    String      value;
    boolean     add;
    Set<String> synchronizedTreeSet;

    public Task(String value, boolean add, Set<String> synchronizedTreeSet) {
        this.value = value;
        this.add = add;
        this.synchronizedTreeSet = synchronizedTreeSet;
    }

    @Override
    public void run() {

        String threadName = Thread.currentThread().toString();

        if (add) {
            System.out.println(threadName + "# add: " + value);
            synchronizedTreeSet.add(value);
        } else {
            boolean contains = synchronizedTreeSet.contains(value);

            System.out.println(threadName + "# treeSet.contains: " + value + " = " + contains + " removed...");

            if (contains) {
                synchronizedTreeSet.remove(value);
            }
        }

    }
}

public static void main(String[] args) throws InterruptedException {

    //
    // synchronizedSet
    //
    Set<String> treeSet = Collections.synchronizedSet(new TreeSet<String>());

    //
    // ThreadPool with ? Threads
    //
    int processors = Runtime.getRuntime().availableProcessors();
    ExecutorService threadPool = Executors.newFixedThreadPool(processors);

    for (int i = 0; i < 100; i++) {

        String someValue = "" + (i % 5);
        boolean addOrCheck = Math.random() > 0.5;

        threadPool.execute(new Task(someValue, addOrCheck, treeSet));
    }

    //
    // don't forget to kill the threadpool
    //
    threadPool.shutdown();
}

}