Prioridades das threads

#java

Conceito Principal:
Cada thread em Java possui uma prioridade associada que influencia a quantidade de tempo de CPU que a thread recebe em relação a outras threads em execução. Prioridades são configuradas usando os métodos setPriority(int nível) e getPriority(). Os níveis variam de 1 (MIN_PRIORITY) a 10 (MAX_PRIORITY), sendo 5 (NORM_PRIORITY) o padrão.

Embora a prioridade possa impactar o agendamento, outros fatores, como bloqueios de recursos e a implementação do sistema operacional, também afetam a execução.

Código Explicado
O código a seguir demonstra como configurar e observar o impacto das prioridades:

// Demonstra as prioridades das threads.
class Priority implements Runnable {
    int count;
    Thread thrd;
    static boolean stop = false;
    static String currentName;

    // Construtor para criar uma nova thread
    Priority(String name) {
        thrd = new Thread(this, name);
        count = 0;
        currentName = name;
    }

    // Define o comportamento da thread
    public void run() {
        System.out.println(thrd.getName() + " starting.");
        do {
            count++;
            if (!currentName.equals(thrd.getName())) {
                currentName = thrd.getName();
                System.out.println("In " + currentName);
            }
        } while (!stop && count < 10000000);
        stop = true; // Interrompe outras threads ao alcançar 10.000.000
        System.out.println("\n" + thrd.getName() + " terminating.");
    }
}

class PriorityDemo {
    public static void main(String args[]) {
        // Cria duas threads com diferentes prioridades
        Priority mt1 = new Priority("High Priority");
        Priority mt2 = new Priority("Low Priority");

        // Configura as prioridades
        mt1.thrd.setPriority(Thread.NORM_PRIORITY + 2); // Alta prioridade
        mt2.thrd.setPriority(Thread.NORM_PRIORITY - 2); // Baixa prioridade

        // Inicia as threads
        mt1.thrd.start();
        mt2.thrd.start();

        try {
            mt1.thrd.join();
            mt2.thrd.join();
        } catch (InterruptedException exc) {
            System.out.println("Main thread interrupted.");
        }

        // Exibe os resultados
        System.out.println("\nHigh priority thread counted to " + mt1.count);
        System.out.println("Low priority thread counted to " + mt2.count);
    }
}

O que acontece no programa?

Threads com diferentes prioridades:
A thread mt1 possui uma prioridade mais alta que mt2.
Isso significa que mt1 tem maior chance de acessar a CPU, mas não garantia absoluta.

Laço de contagem e alternância de threads:
Cada thread incrementa uma variável count até alcançar 10.000.000.
Se uma thread terminar primeiro, a variável estática stop interrompe a outra.

Observação da alternância:
O nome da thread é exibido quando a execução alterna entre threads (currentName).

Prioridade e resultados:
No exemplo típico, a thread de alta prioridade (High Priority) executa mais rápido, alcançando a meta de 10.000.000 enquanto a outra thread é interrompida.

Saída Exemplo

High Priority starting.
In High Priority
Low Priority starting.
In Low Priority
In High Priority
High Priority terminating.
Low Priority terminating.

High priority thread counted to 10000000
Low priority thread counted to 8183

Pontos de Observação:

A saída pode variar dependendo do sistema operacional, da carga do sistema e do hardware.
Em sistemas multicore, o impacto das prioridades pode ser menos perceptível, já que múltiplas threads podem ser executadas simultaneamente.