同时启动多个线程

Question

For our assignment for class, we have to count the amount of words in a txt file by splitting it into n segments, which we are supposed to be able to set before launching the programm. Each segment should then get its own thread, which counts the words and then stops. At the end, the main thread should collect all the individual word counts and add them together.

This is (part of) what I wrote so far

for (int i = 0; i < segments; i++){
            Thread thread = new Thread();
            thread.start();
            int words = counting(stringarray[i]);
            totalwords += words;
            long nanos = ManagementFactory.getThreadMXBean().getThreadCpuTime(Thread.currentThread().getId());
            System.out.println("This Thread read " + words + " words. The total word count now is " + totalwords + 
                    ". The time it took to finish for this thread is " + nanos +".");
            System.out.println("Number of active threads from the given thread: " + Thread.activeCount());
        }

Now, while this gets the primary job done (counting the words in different threads and adding them to the total), I dont know how to just "leave the thread be" and then add the individual wordcounts together after every thread has done its job.

Additionally, while this is definitely starting multiple threads, it only ever prints out that I have 2, or maybe 3 threads running at a time, even if I split the txt into 100 segments. Is there a way to have them all run at the same time?

Answer 1

The wording of the question suggest that each thread has its own counter, so I would declare a thread class:

public class WordCounter extends Thread {
    private String text;
    private int count;

    public WordCounter(String text) {
        this.text = text;
    }

    public int getCount() {
        return count;
    }

    @Override
    public void run() {
        count = counting(text);
    }
}

and use it as follows:

WordCounter[] threads = new WordCounter[segments];
for (int i = 0; i < segments; ++i) {
    threads[i] = new WordCounter(stringarray[i]);
    threads[i].start();
}
int total = 0;
for (int i = 0; i < segments; ++i) {
    threads[i].join();
    total += threads[i].getCount();
}

Answer 2

You may use next code snippet as a basis. Note, that in case you increment common variable in different threads, this operation has to be thread-safe. That's why AtomicInteger variable is used as a counter

final List<String> segments = new ArrayList<>();
//TODO:Fill segments ... this is up to you
//In case threads will increment same variable it has to be thread-safe
final AtomicInteger worldCount = new AtomicInteger();
//Create Thread for each segment (this is definitely not optimal)
List<Thread> workers = new ArrayList<>(segments.size());
for (int i = 0; i < segments.size(); i++) {
    final String segment = segments.get(i);
    Thread worker = new Thread(new Runnable() {
        @Override
        public void run() {
            //increment worldCount
            worldCount.addAndGet(counting(segment));
        }
    });
    workers.add(worker);
    worker.start();
}

//Wait until all Threads are finished
for (Thread worker : workers) {
    worker.join();
}
int result = worldCount.get();

Answer 3

Same solutions, but with Executors:

    final List<String> segments = new ArrayList<>();
    segments.add("seg1");
    segments.add("seg2");
    segments.add("seg 3");

    final AtomicInteger worldCount = new AtomicInteger();

    List<Future> workers = new ArrayList<>(segments.size());
    ExecutorService executor = Executors.newFixedThreadPool(segments.size());
    for (String segment : segments) {
        Future<Integer> worker = executor.submit(() -> worldCount.addAndGet(counting(segment)));
        workers.add(worker);
    }

    executor.shutdown();
    if (!executor.awaitTermination(5, TimeUnit.SECONDS)) {
        System.out.println("Still waiting...");
        System.exit(0);
    }

    int result = worldCount.get();

    System.out.println("result = " + result);