Java ThreadPool 重用可运行对象而不是为每个任务创建新对象

Question

I'm trying to make my Dijkstra algorithm more efficient by reusing the runnable object instead of creating a new one for each task in the ThreadPool. Each task needs 3 parameters(start value, end value and a CountDownLatch). I tried using getters/setters and this works everywhere except for in the run() method of the thread class. It keeps reusing one variable and this screws up the algorithm

This is the thread class, the run() executes a method to look for the next closest node in the graph. The variables and getters are global:

//Thread class
        class ClosestNodeTask implements Runnable {

            @Override
            public void run() {
                getNodeShortestDistanced(getStart(), getEnd(), getCdlClosest());
            }
        }

The code snippets below are executed in an apply() method.

Creation of object(once):

ClosestNodeTask closestNodeTask = new ClosestNodeTask();

This snippet gives the tasks for the thread pool to execute:

for (int t = 0; t < numberOfThreads; t++) {
      int start;
      int end;

      if (nodesModulo > 0 && numberOfThreads == (t + 1)) {
        start = nodesPerThread * (t);
        end = nodesPerThread * (t + 1) + nodesModulo;

        setStart(start);
        setEnd(end);
        setCdlClosest(cdlClosest);

        executor.execute(closestNodeTask);
      } else {
        start = nodesPerThread * t;
        end = nodesPerThread * (t + 1);

        setStart(start);
        setEnd(end);
        setCdlClosest(cdlClosest);

        executor.execute(closestNodeTask);
    }
}

The output of the 'start' variable is with two threads: 0 and 12500. If I do a getstart() in the run() of the runnable object it always returns 12500, thus messing up the algorithm. If I do a getstart() everywhere else I always get the correct outputs of 0 and 12500.

What am I doing wrong? I don't understand why the run() method keeps reusing the same variable.

Answer 1

When you create a single object and use it in multiple threads, you're essentially sharing a common state with all those threads. That is, when you can setStart(), etc. you're setting the start for all running threads as well as the new one you're creating.

You need separate objects for each thread. This is either in the form of separate instances of the class you're running or as thread-local variables, which is less efficient.