pratical2.java

import java.io.*;
import java.util.*;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class WordCountTask extends Thread {
    private final List<String> lines;
    private final SharedResult sharedResult;

    public WordCountTask(List<String> lines, SharedResult sharedResult, String name) {
        super(name); // set thread name
        this.lines = lines;
        this.sharedResult = sharedResult;
    }

    @Override
    public void run() {
        System.out.println(getName() + " started.");
        int localCount = 0;

        for (String line : lines) {
            String[] words = line.trim().split("\\s+");
            localCount += words.length;

            // Example: also check for a pattern (e.g., "Java")
            for (String word : words) {
                if (word.equalsIgnoreCase("Java")) {
                    sharedResult.addPatternMatch("Java found by " + getName());
                }
            }
        }

        // Add result to shared counter safely
        sharedResult.addWordCount(localCount);

        System.out.println(getName() + " finished with count: " + localCount);
    }
}

// Shared resource class with synchronization
class SharedResult {
    private int totalWords = 0;
    private final List<String> patternMatches = new ArrayList<>();
    private final Lock lock = new ReentrantLock();

    // synchronized method
    public synchronized void addWordCount(int count) {
        totalWords += count;
    }

    // lock-based protection
    public void addPatternMatch(String match) {
        lock.lock();
        try {
            patternMatches.add(match);
        } finally {
            lock.unlock();
        }
    }

    public int getTotalWords() {
        return totalWords;
    }

    public List<String> getPatternMatches() {
        return patternMatches;
    }
}

public class Practical2 {
    public static void main(String[] args) {
        String filePath = "large_text.txt"; // replace with your file path

        List<String> allLines = new ArrayList<>();
        try (BufferedReader br = new BufferedReader(new FileReader(filePath))) {
            String line;
            while ((line = br.readLine()) != null) {
                allLines.add(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
            return;
        }

        int numThreads = 4; // divide work among 4 threads
        int chunkSize = allLines.size() / numThreads;

        SharedResult sharedResult = new SharedResult();
        List<Thread> threads = new ArrayList<>();

        // create threads
        for (int i = 0; i < numThreads; i++) {
            int start = i * chunkSize;
            int end = (i == numThreads - 1) ? allLines.size() : (i + 1) * chunkSize;
            List<String> subList = allLines.subList(start, end);

            Thread t = new WordCountTask(subList, sharedResult, "Worker-" + (i + 1));
            threads.add(t);
            t.start(); // thread lifecycle: created → running
        }

        // wait for all threads to finish
        for (Thread t : threads) {
            try {
                t.join(); // wait for termination
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        // final result
        System.out.println("\n=== Final Result ===");
        System.out.println("Total word count: " + sharedResult.getTotalWords());
        System.out.println("Pattern matches:");
        for (String match : sharedResult.getPatternMatches()) {
            System.out.println(match);
        }
    }
}