import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.locks.*;

// Finn minste tall med barriere

// Skrevet av Stein Gjessing 2017-2025 og
// Magnus Skjegstad 2026-

class Minst2 {
    final static int ANTALL_TRADER = 64;
    final static int TALL_PER_TRAD = 1_000_000;
    final static int TOTAL = ANTALL_TRADER * TALL_PER_TRAD;

    public static void main(String[] args) throws InterruptedException {
        System.out.println("Genererer tilfeldige data...");

        Random tilfeldigeTall = new Random();

        int[] innData = new int[TOTAL];
        for (int i = 0; i < TOTAL; i++) {
            innData[i] = Math.abs(tilfeldigeTall.nextInt());
        }

        System.out.println("Data klare, starter " + ANTALL_TRADER + " tr?der");

        CountDownLatch barriere = new CountDownLatch(ANTALL_TRADER);

        MinstMonitor monitor = new MinstMonitor();
        Thread[] tr?der = new Thread[ANTALL_TRADER];
        for (int i = 0; i < ANTALL_TRADER; i++) {
            int start = i * TALL_PER_TRAD;
            int slutt = start + TALL_PER_TRAD;
            Runnable minstRunP = new MinstRun(monitor, innData, start, slutt, barriere);
            tr?der[i] = new Thread(minstRunP);
            tr?der[i].start();
        }

        barriere.await();

        System.out.println("Minste verdi er " + monitor.hentMinste());
    }
}

class MinstMonitor {
    private Lock l?s = new ReentrantLock();
    private int minstTilN? = Integer.MAX_VALUE;

    public void giMinsteVerdi(int minsteVerdi) {
        l?s.lock();
        try {
            if (minsteVerdi < minstTilN?) {
                this.minstTilN? = minsteVerdi;
            }
        } finally {
            l?s.unlock();
        }
    }

    public int hentMinste() {
        l?s.lock();
        try {
            return minstTilN?;
        } finally {
            l?s.unlock();
        }
    }
}

class MinstRun implements Runnable {
    private MinstMonitor monitor;
    private int[] tabell;
    private int startPosisjon;
    private int sluttPosisjon;
    private CountDownLatch barriere;

    MinstRun(MinstMonitor monitor, int[] tabell, int startPosisjon, int sluttPosisjon, CountDownLatch barriere) {
        this.monitor = monitor;
        this.tabell = tabell;
        this.startPosisjon = startPosisjon;
        this.sluttPosisjon = sluttPosisjon;
        this.barriere = barriere;
    }

    @Override
    public void run() {
        int minVerdi = Integer.MAX_VALUE;
        for (int i = this.startPosisjon; i < this.sluttPosisjon; i++) {
            if (this.tabell[i] < minVerdi) {
                minVerdi = this.tabell[i];
            }
        }
        this.monitor.giMinsteVerdi(minVerdi);
        barriere.countDown();
    }
}