Counting Vowels Using Multithreading in Java

Counting vowels in a large string can be a time-consuming task, especially when working with large input data. One way to improve the performance of this task is by using multithreading in Java. Multithreading allows you to divide the task of counting vowels into smaller, concurrent tasks that can be executed in parallel, which can significantly reduce the overall processing time.

To count vowels using multithreading in Java, you can create a Thread class that runs a loop to check each character of a given String for vowels (i.e. 'a', 'e', 'i', 'o', 'u'). In the main method, you can create multiple instances of the Thread class, each assigned a portion of the String to check, and then start each thread. This way, the program can check different sections of the String concurrently, which can improve performance.

Another way to implement multithreading in Java is by using the Executor framework.

You can also use Executor framework which is a higher-level framework built on top of thread pooling. You can use Executor framework to easily create and manage threads, and it also provides more advanced features like thread pooling, which can help improve performance even further.

Here is sample code that uses the Executor framework to count vowels in a String using multithreading:

VowelCounter.java

public class VowelCounter {
    private final String str;
    private int vowelCount = 0;
    public VowelCounter(String str) {
        this.str = str;
    }
    public void countVowels() {
        Executor executor = Executors.newFixedThreadPool(10);
        for (int i = 0; i < str.length(); i++) {
            final int index = i;
            executor.execute(new Runnable() {
                @Override
                public void run() {
                    if (isVowel(str.charAt(index))) {
                        vowelCount++;
                    }
                }
            });
        }
    }
    private boolean isVowel(char c) {
        c = Character.toLowerCase(c);
        return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u';
    }
    public int getVowelCount() {
        return vowelCount;
    }
    public static void main(String[] args) {
        VowelCounter counter = new VowelCounter("Hello, World!");
        counter.countVowels();
        System.out.println("Vowel count: " + counter.getVowelCount());
    }
}

Output:

Vowel count: 3

In this example, the VowelCounter class is created with a constructor that takes a String as input. The countVowels() method creates an Executor with a fixed thread pool of size 10 and then runs a loop that iterates through each character in the String. For each character, it creates a new Runnable task that checks if the character is a vowel and, if so, increments the vowelCount variable.

The code creates an instance of the VowelCounter class with the String "Hello, World!" and calls the countVowels() method. This method creates an Executor with a fixed thread pool of size 10 and then runs a loop that iterates through each character in the String. For each character, it creates a new Runnable task that checks if the character is a vowel and, if so, increments the vowelCount variable.

After all the characters have been processed, the main method calls the getVowelCount() method to retrieve the final count of vowels and prints it out to the console using the line:

System.out.println("Vowel count: " + counter.getVowelCount());

Since the input string contains 3 vowels (e, o, and o), the final count of vowels is 3.

It's important to note that the above example uses a simple approach for counting the vowels and it's not the most optimized solution for large inputs.

Here is another example of counting vowels using multithreading in Java, this time using the Thread class:

VowelCounter.java

public class VowelCounter {
    private final String str;
    private int vowelCount = 0;
    public VowelCounter(String str) {
        this.str = str;
    }
    public void countVowels() {
        int threadCount = 4; // number of threads
        int chunkSize = str.length() / threadCount;
        CountVowelsThread[] threads = new CountVowelsThread[threadCount];
        // Create and start threads
        for (int i = 0; i < threadCount; i++) {
            int start = i * chunkSize;
            int end = (i + 1) * chunkSize;
            if (i == threadCount - 1) {
                end = str.length(); // last thread takes remaining characters
            }
            threads[i] = new CountVowelsThread(str.substring(start, end));
            threads[i].start();
        }
        // Wait for threads to finish
        for (CountVowelsThread thread : threads) {
            try {
                thread.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            vowelCount += thread.getVowelCount();
        }
    }
    public int getVowelCount() {
        return vowelCount;
    }
    public static void main(String[] args) {
        VowelCounter counter = new VowelCounter("Hello, World!");
        counter.countVowels();
        System.out.println("Vowel count: " + counter.getVowelCount());
    }
    private class CountVowelsThread extends Thread {
        private final String str;
        private int vowelCount = 0;
        public CountVowelsThread(String str) {
            this.str = str;
        }
        @Override
        public void run() {
            for (int i = 0; i < str.length(); i++) {
                if (isVowel(str.charAt(i))) {
                    vowelCount++;
                }
            }
        }
        public int getVowelCount() {
            return vowelCount;
        }
    }
    private boolean isVowel(char c) {
        c = Character.toLowerCase(c);
        return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u';
    }
}

Output:

Vowel count: 3