Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / Java

ArrayBlockingQueue(int): capacidade da fila e tempo de inatividade

Cria uma fila de capacidade fixa com duas vagas e distingue esse limite do tempo de inatividade zero para as threads excedentárias do pool.

Versão: Java SE 21

Sintaxe

public ArrayBlockingQueue(int capacity)

// Java SE 21: a queue with two slots for waiting tasks
new ThreadPoolExecutor(1, 2, 0L, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(2))

Em Java SE 21, ArrayBlockingQueue(int), de java.util.concurrent, cria uma fila bloqueante vazia, suportada por um array e com capacidade fixa. Com 2, a fila pode conter até dois elementos em simultâneo; uma capacidade nula ou negativa lança IllegalArgumentException. Os elementos são retirados por ordem FIFO, mas a política predefinida não garante a ordem de acesso das threads em espera. Para lhes dar acesso por ordem FIFO, usa a sobrecarga ArrayBlockingQueue(int, boolean) com true.

Quando a fila está cheia, offer(E) devolve false sem esperar por espaço, enquanto put(E) espera que haja espaço, salvo se a thread for interrompida. Quando usada como fila de trabalho de um ThreadPoolExecutor, a capacidade limita o número de tarefas à espera na fila, não o número de threads nem o total de tarefas aceites.

No construtor de ThreadPoolExecutor, 0L é um literal de tipo long com valor zero. O literal 0 é do tipo int e também serve para este parâmetro através de uma conversão de alargamento para long. TimeUnit.MILLISECONDS é uma constante de enumeração de java.util.concurrent; um milissegundo é um milésimo de segundo. Um tempo de inatividade de 0L nesta unidade significa que as threads inativas acima de corePoolSize terminam sem esperar por novas tarefas. Não é um limite à duração das tarefas. Por predefinição, as threads do núcleo não terminam por inatividade; allowCoreThreadTimeOut(true) exige um tempo de inatividade positivo.

Exemplos

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Main {
    public static void main(String[] args) {
        var queue = new ArrayBlockingQueue<String>(2);
        System.out.println(queue.offer("A"));
        System.out.println(queue.offer("B"));
        System.out.println(queue.offer("C"));

        try (var executor = new ThreadPoolExecutor(
                1, 2, 0L, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(2))) {
            System.out.println("keepAliveMs=" + executor.getKeepAliveTime(TimeUnit.MILLISECONDS));
        }
    }
}

Resultado

true
true
false
keepAliveMs=0

A fila independente aceita dois elementos e recusa o terceiro (`false`). O executor tem a sua própria fila com duas vagas. O programa lê `keepAliveMs=0` sem executar tarefas nem medir o tempo de vida das threads.

Lições relacionadas

  • Java · Lição 37 · Avançado · Versão: 2
  • Java · Lição 42 · Avançado · Versão: 2

Fontes