threadsOverhead.js

const { 
    Worker, 
    isMainThread, 
    parentPort, 
    workerData } = require('worker_threads');
const { performance } = require('perf_hooks');

// Função para encontrar números primos em um intervalo
const findPrimes = (start, end) => {
    const primes = [];

    // Itera por todos os números no intervalo [start, end]
    for (let i = start; i <= end; i++) {
        let isPrime = true;

        // Verifica se o número 'i' é divisível por algum número 
        // entre 2 e sua raiz quadrada
        for (let j = 2, sqrt = Math.sqrt(i); j <= sqrt; j++) {
            if (i % j === 0) {
                isPrime = false;
                break;
            }
        }

        // Se 'i' for primo (e maior que 1), adiciona-o ao 
        // array de primos
        if (isPrime && i > 1) {
            primes.push(i);
        }
    }

    return primes;
}

// Função para calcular números primos em um único thread
function singleThread(max) {
    // Marca o início da medição de tempo
    const stStart = performance.now(); 

    // Chama a função para encontrar números primos no 
    // intervalo [2, max]
    findPrimes(2, max); 

     // Marca o final da medição de tempo
    const stEnd = performance.now();
    // Imprime o tempo decorrido em milissegundos
    console.log('Single-threaded:', stEnd - stStart, 'ms'); 
}

// Função para calcular números primos em vários threads
function multiThread(max, numbersPerThread, threadCount) {
    const mtStart = performance.now(); // Marca o início da medição de tempo
    let completed = 0;

    for (let i = 0; i < threadCount; i++) {
        const start = i * numbersPerThread + 2;
        const end = i === threadCount - 1 ? max : start + numbersPerThread - 1;

        // Cria um novo thread para calcular primos em um subintervalo
        const worker = new Worker(__filename, {
            workerData: { start, end }
        });

        // Quando o thread conclui, incrementa o contador 'completed'
        // e verifica se todos os threads terminaram para medir o tempo total
        worker.on('message', () => {
            completed++;
            if (completed === threadCount) {
                // Marca o final da medição de tempo quando todos os threads terminam
                const mtEnd = performance.now(); 
                 // Imprime o tempo decorrido em milissegundos
                console.log('Multi-threaded:', mtEnd - mtStart, 'ms');
            }
        });
    }
}

// Se estiver no thread principal
if (isMainThread) {
    // Define o número máximo no intervalo
    const max = 1e5; 
    // Define o número total de threads a serem usadas
    const threadCount = 4; 
    // Calcula quantos números cada thread deve processar
    const numbersPerThread = Math.ceil(max / threadCount); 
    // Calcula primos em um único thread
    singleThread(max);

    // Calcula primos em múltiplos threads
    multiThread(max, numbersPerThread, threadCount);
} else {
    // Se estiver em um thread
    // Recebe os dados de start e end do intervalo a ser processado
    const { start, end } = workerData; 
    // Chama a função para encontrar primos no intervalo especificado
    findPrimes(start, end); 
    // Envia uma mensagem de conclusão após o cálculo
    parentPort.postMessage(true); 
}