Word Count Using Multithreading in Java

One typical issue in text processing is word count. Java multithreading can greatly speed up the process by breaking the task up into smaller parts and processing them simultaneously. In his section, we will discuss the different approaches of word count of using Java multithreading.

Using Thread Class

In this method, we will create a custom thread class that extends Thread. Each thread will process a portion of the text and count the words.

File Name: WordCountUsingThread.java

import java.util.Arrays;
class WordCountThread extends Thread {
    private String[] words;
    private int start;
    private int end;
    private int wordCount;
    public WordCountThread(String[] words, int start, int end) {
        this.words = words;
        this.start = start;
        this.end = end;
    }
    public int getWordCount() {
        return wordCount;
    }
    @Override
    public void run() {
        wordCount = 0;
        for (int i = start; i < end; i++) {
            if (!words[i].isEmpty()) {
                wordCount++;
            }
        }
    }
}
public class WordCountUsingThread {
    public static void main(String[] args) {
        String text = "This is a sample text for word count using multithreading in Java.";
        String[] words = text.split("\\s+");
        int numberOfThreads = 4;
        WordCountThread[] threads = new WordCountThread[numberOfThreads];
        int wordsPerThread = words.length / numberOfThreads;
        for (int i = 0; i < numberOfThreads; i++) {
            int start = i * wordsPerThread;
            int end = (i + 1) * wordsPerThread;
            if (i == numberOfThreads - 1) {
                end = words.length;
            }
            threads[i] = new WordCountThread(words, start, end);
            threads[i].start();
        }
        int totalWordCount = 0;
        for (WordCountThread thread : threads) {
            try {
                thread.join();
                totalWordCount += thread.getWordCount();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("Total word count: " + totalWordCount);
    }
}

Output:

Total word count: 12

Using Runnable Interface

The method creates threads using the Runnable interface. It is a more flexible approach, as the Runnable interface can be implemented by any class.

File Name: WordCountUsingRunnable.java

import java.util.Arrays;
class WordCountRunnable implements Runnable {
    private String[] words;
    private int start;
    private int end;
    private int wordCount;
    public WordCountRunnable(String[] words, int start, int end) {
        this.words = words;
        this.start = start;
        this.end = end;
    }
    public int getWordCount() {
        return wordCount;
    }
    @Override
    public void run() {
        wordCount = 0;
        for (int i = start; i < end; i++) {
            if (!words[i].isEmpty()) {
                wordCount++;
            }
        }
    }
}
public class WordCountUsingRunnable {
    public static void main(String[] args) {
        String text = "This is a sample text for word count using multithreading in Java.";
        String[] words = text.split("\\s+");
        int numberOfThreads = 4;
        Thread[] threads = new Thread[numberOfThreads];
        WordCountRunnable[] runnables = new WordCountRunnable[numberOfThreads];
        int wordsPerThread = words.length / numberOfThreads;
        for (int i = 0; i < numberOfThreads; i++) {
            int start = i * wordsPerThread;
            int end = (i + 1) * wordsPerThread;
            if (i == numberOfThreads - 1) {
                end = words.length;
            }
            runnables[i] = new WordCountRunnable(words, start, end);
            threads[i] = new Thread(runnables[i]);
            threads[i].start();
        }
        int totalWordCount = 0;
        for (int i = 0; i < numberOfThreads; i++) {
            try {
                threads[i].join();
                totalWordCount += runnables[i].getWordCount();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("Total word count: " + totalWordCount);
    }
}

Output:

Total word count: 12

Using ExecutorService

The ExecutorService framework in Java provides a higher-level replacement for working with threads directly. It simplifies thread management and improves scalability.

File Name: WordCountUsingExecutorService.java

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.List;
import java.util.ArrayList;
class WordCountTask implements Callable<Integer> {
    private String[] words;
    private int start;
    private int end;
    public WordCountTask(String[] words, int start, int end) {
        this.words = words;
        this.start = start;
        this.end = end;
    }
    @Override
    public Integer call() {
        int wordCount = 0;
        for (int i = start; i < end; i++) {
            if (!words[i].isEmpty()) {
                wordCount++;
            }
        }
        return wordCount;
    }
}
public class WordCountUsingExecutorService {
    public static void main(String[] args) {
        String text = "This is a sample text for word count using multithreading in Java.";
        String[] words = text.split("\\s+");
        int numberOfThreads = 4;
        ExecutorService executorService = Executors.newFixedThreadPool(numberOfThreads);
        List<Future<Integer>> futures = new ArrayList<>();
        int wordsPerThread = words.length / numberOfThreads;
        for (int i = 0; i < numberOfThreads; i++) {
            int start = i * wordsPerThread;
            int end = (i + 1) * wordsPerThread;
            if (i == numberOfThreads - 1) {
                end = words.length;
            }
            WordCountTask task = new WordCountTask(words, start, end);
            futures.add(executorService.submit(task));
        }
        int totalWordCount = 0;
        for (Future<Integer> future : futures) {
            try {
                totalWordCount += future.get();
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
        }
        executorService.shutdown();
        System.out.println("Total word count: " + totalWordCount);
    }
}

Output:

Total word count: 12

Conclusion

Multithreading can greatly increase the efficiency of word count operations, particularly for lengthy texts. The ExecutorService provides a more flexible and scalable solution, while the Thread and Runnable classes provide a more fundamental approach. Every method has a set of use cases and can be selected according to the particular needs of the application.

Next TopicCan-we-make-the-main-thread-as-daemon-in-java

← prev next →