Main.java

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import Arquivo.Arquivo;
import Output.Output;
import Enums.TipoThread;
import Thread.MinhaThread;
import Utils.Constantes;
import Controle.*;

public class Main {

    public static void main(String[] args) {
        Arquivo arquivo = new Arquivo("bd.txt");
        var linhas = arquivo.lerLinhas();

        if (linhas.isEmpty())
            throw new RuntimeException("Falha ao carregar as palavras do arquivo bd.txt");

        // --- INÍCIO DO EXPERIMENTO 1: BLOQUEIO SIMPLES ---
        System.out.println("--- INICIANDO TESTE: BLOQUEIO_SIMPLES ---");

        Output o1 = new Output("bloqueio_simples");

        if (o1.ChecarOutput() == false) {

            List<String> conteudo1 = new ArrayList<>();

            for (int i = 0; i <= Constantes.NUMERO_MAXIMO_THREADS; i++) {
                int escritores = i;
                int leitores = Constantes.NUMERO_MAXIMO_THREADS - escritores;

                double tempoMedio = Rodar(escritores, leitores, linhas, "BLOQUEIO_SIMPLES");
                conteudo1.add(leitores + "," + tempoMedio);
            }

            o1.CriarOutput(conteudo1);

            System.out.println("--- TESTE BLOQUEIO_SIMPLES FINALIZADO ---");

        } else {
            System.out.println("Teste foi já realizado");
        }

        // --- INÍCIO DO EXPERIMENTO 2: LEITOR/ESCRITOR ---

        System.out.println("\n--- INICIANDO TESTE: LEITOR_ESCRITOR ---");

        Output o2 = new Output("leitor_escritor");

        if (o2.ChecarOutput() == false) {

            // (Nota: É crucial recarregar o arquivo aqui, porque o primeiro
            // experimento modificou a lista 'linhas' com "MODIFICADO".
            // Precisamos começar o segundo teste com a base "limpa".)
            linhas = arquivo.lerLinhas();
            if (linhas.isEmpty())
                throw new RuntimeException("Falha ao RECARREGAR as palavras do arquivo bd.txt");

            List<String> conteudo2 = new ArrayList<>();

            for (int i = 0; i <= Constantes.NUMERO_MAXIMO_THREADS; i++) {
                int escritores = i;
                int leitores = Constantes.NUMERO_MAXIMO_THREADS - escritores;

                double tempoMedio = Rodar(escritores, leitores, linhas, "LEITOR_ESCRITOR");
                conteudo2.add(leitores + "," + tempoMedio);
            }

            o2.CriarOutput(conteudo2);

            System.out.println("--- TESTE LEITOR_ESCRITOR FINALIZADO ---");
        } else {
            System.out.println("Teste já foi realizado");
        }
    }

    /**
     * Roda o experimento com a quantidade de leitores e escritores.
     * Será impressa a duração total de todas as rodagens
     * 
     * @param quant_escritores Auto-explicativo
     * @param quant_leitores   Auto-explicativo
     * @param linhas           Região crítica a ser acessada pelas threads
     * 
     */
    private static double Rodar(int quant_escritores, int quant_leitores, List<StringBuffer> linhas,
            String tipoControle) {

        long tempoTotalGasto = 0;

        for (int i = 0; i < Constantes.NUMERO_RODAGENS; i++) {
            IControle controle;
            if (tipoControle.equals("BLOQUEIO_SIMPLES"))
                controle = new ControleBloqueioSimples();
            else
                controle = new ControleLeitorEscritor();
            long startTime = System.currentTimeMillis();
            List<MinhaThread> threads = criarArranjoDeThreads(quant_leitores, quant_escritores, linhas, controle);

            List<Thread> threadsEmExecucao = new ArrayList<>();

            for (Runnable thread : threads) {
                Thread threadEmExecucao = new Thread(thread);
                threadsEmExecucao.add(threadEmExecucao);
                threadEmExecucao.start();
            }

            for (Thread thread : threadsEmExecucao) {
                try {
                    thread.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            long endTime = System.currentTimeMillis();
            tempoTotalGasto += (endTime - startTime);
        }

        double tempoMedio = tempoTotalGasto / 50;

        System.out.println("[" + tipoControle + "]" + " Tempo de execução com " + quant_leitores + " leitores e "
                + quant_escritores + " escritores: " + tempoMedio + " ms");
        return tempoMedio;
    }

    /**
     * Cria um arranjo de threads, embaralhado, com a quantidade de leitores e
     * escritores
     * 
     * @param quant_leitores   Auto-explicativo
     * @param quant_escritores Auto-explicativo
     * @param linhas           Região crítica a ser acessada pelas threads
     * @return Arranjo embaralhado de threads
     * 
     */
    private static List<MinhaThread> criarArranjoDeThreads(int quant_leitores, int quant_escritores,
            List<StringBuffer> linhas, IControle controle) {
        if (quant_escritores + quant_leitores > Constantes.NUMERO_MAXIMO_THREADS) {
            throw new IllegalArgumentException(
                    "A soma de leitores e escritores não pode exceder " + Constantes.NUMERO_MAXIMO_THREADS);
        }

        List<MinhaThread> threads = new ArrayList<>();

        for (int i = 0; i < quant_leitores; i++) {
            threads.add(new MinhaThread(linhas, TipoThread.READER, controle));
        }

        for (int i = 0; i < quant_escritores; i++) {
            threads.add(new MinhaThread(linhas, TipoThread.WRITER, controle));
        }

        // Faz-se necessário embaralhar o arranjo
        Collections.shuffle(threads);

        return threads;
    }
}