java multithreading beginner issue

A more typical and scalable approach is one of the following:

• create a collection (likely an array or list) of N threads to perform the work
• use a thread pool, e.g. from Executors.newFixedThreadPool(N)

You may also wish to use a Producer Consumer pattern in which the threads pull from a common task pool. This allows natural balancing of the work - instead of essentially hard-coding one thread handles 500 tasks and the other the same number.

Consider after all what would happen if all of your larger files end up in the bucket handled by the Thread2? The first thread is done/idle and the second thread has to do all of the heavy lifting.

The producer/consumer pooling approach would be to dump all of the work (generated by the Producer's) into a task pool and then the Consumers (your worker threads) bite off small pieces (e.g. one file) at a time. This approach leads to keeping both threads occupied for a similar duration.

In learning multi-threaded programming one of the important insights is that a thread is not a task. By giving a thread a part of the list of items to process you are halfway there but the next step will take you further: constructing the task in such a way that any number of threads can execute it. To do this, you will have to get familiar with the java.util.concurrent classes. These are useful tools to help constructing the tasks.

The example below separates tasks from threads. It uses AtomicInteger to ensure each thread picks a unique task and it uses CountDownLatch to know when all work is done. The example also shows balancing: threads that execute tasks that complete faster, execute more tasks. The example is by no means the only solution - there are other ways of doing this that could be faster, easier, better to maintain, etc..

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;

public class MultiRename implements Runnable {

public static void main(String[] args) {

    final int numberOfFnames = 50;

    MultiRenameParams params = new MultiRenameParams();
    params.fnameList = new ArrayList<String>();
    for (int i = 0; i < numberOfFnames; i++) {
        params.fnameList.add("fname " + i);
    }
    params.fnameListIndex = new AtomicInteger();

    final int numberOfThreads = 3;

    params.allDone = new CountDownLatch(numberOfThreads);
    ExecutorService tp = Executors.newCachedThreadPool();
    System.out.println("Starting");
    for (int i = 0; i < numberOfThreads; i++) {
        tp.execute(new MultiRename(params, i));
    }
    try { params.allDone.await(); } catch (Exception e) {
        e.printStackTrace();
    }
    tp.shutdownNow();
    System.out.println("Finished");
}

private final MultiRenameParams params;
private final Random random = new Random();
// Just to show there are fast and slow tasks.
// Thread with lowest delay should get most tasks done.
private final int delay;

public MultiRename(MultiRenameParams params, int delay) {
    this.params = params;
    this.delay = delay;
}

@Override
public void run() {

    final int maxIndex = params.fnameList.size();
    int i = 0;
    int count = 0;
    while ((i = params.fnameListIndex.getAndIncrement()) < maxIndex) {
        String fname = params.fnameList.get(i);
        long sleepTimeMs = random.nextInt(10) + delay;
        System.out.println(Thread.currentThread().getName() + " renaming " + fname + " for " + sleepTimeMs + " ms.");
        try { Thread.sleep(sleepTimeMs); } catch (Exception e) {
            e.printStackTrace();
            break;
        }
        count++;
    }
    System.out.println(Thread.currentThread().getName() + " done, renamed " + count + " files.");
    params.allDone.countDown();
}

static class MultiRenameParams {

    List<String> fnameList;
    AtomicInteger fnameListIndex;
    CountDownLatch allDone;
}

}