Compartilhamento de tecnologia

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

fila de bloqueio

1. Conceito

A fila de bloqueio é um tipo especial de fila. Ela também segue o princípio “primeiro a entrar, primeiro a sair”.

A fila de bloqueio pode ser uma estrutura de dados thread-safe e possui as seguintes características:

• Quando a fila estiver cheia, continuar a entrar na fila será bloqueado até que outros threads retirem elementos da fila..
• Quando a fila está vazia, continuar a desenfileirar também bloqueará até que outros threads insiram elementos na fila.

Um cenário típico de aplicação de fila de bloqueio é o "modelo produtor-consumidor". Este é um modelo de desenvolvimento muito típico.
produtor

O modelo do consumidor resolve o forte problema de acoplamento entre produtores e consumidores através de um contêiner.

Produtores e consumidores não se comunicam diretamente entre si, mas sim por meio de filas de bloqueio. Portanto, após o produtor produzir os dados, ele não precisa esperar que o consumidor os processe, mas os joga diretamente na fila de bloqueio. não solicita dados ao produtor. Em vez disso, eles são obtidos diretamente da fila de bloqueio.

Existem duas etapas principais na implementação do modelo produtor-consumidor:

1. produtor de implementos
2. perceber consumidor

2. Bloqueio de fila na biblioteca padrão

Há uma fila de bloqueio incorporada na biblioteca padrão Java. Se precisarmos usar filas de bloqueio em alguns programas, podemos usar diretamente a fila de bloqueio na biblioteca padrão.
Pode.

• BlockingQueue é uma interface. A classe de implementação real é LinkedBlockingQueue.
• O método put é usado para bloquear a entrada da fila e o método take é usado para bloquear a saída da fila.
• BlockingQueue também possui métodos como offer, poll e peek, mas esses métodos não possuem características de bloqueio.

O pseudocódigo para bloquear a fila é o seguinte:

BlockingQueue<String> queue = new LinkedBlockingQueue<>();

// ⼊队列
queue.put("abc");

// 出队列. 如果没有 put 直接 take, 就会阻塞.
String elem = queue.take();
1
2
3
4
5
6
7

3. Modelo produtor-consumidor

public static void main(String[] args) throws InterruptedException {

	BlockingQueue<Integer> blockingQueue = new LinkedBlockingQueue<Integer>();
	
	Thread customer = new Thread(() -> {
		while (true) {
			try {
				int value = blockingQueue.take();
				System.out.println("消费元素: " + value);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}, "消费者");
	
customer.start();

	Thread producer = new Thread(() -> {
		Random random = new Random();
		while (true) {
			try {
				int num = random.nextInt(1000);
				System.out.println("生产元素: " + num);
				blockingQueue.put(num);
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}, "生产者");
	
	producer.start();
	customer.join();
	producer.join();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

4. Bloqueio de implementação de fila

1. Isto é conseguido através do método de "fila circular".
2. Use sincronizado para controle de bloqueio.
3. Quando put insere um elemento, ele determina se a fila está cheia e espera (observe que a espera deve ser executada em um loop. Quando é despertada, a fila pode não estar cheia porque vários threads podem ser despertados ao mesmo tempo.) .
4. Quando take retira o elemento, ele determina se a fila está vazia e espera (também é um loop de espera).

public class BlockingQueue {

	private int[] items = new int[1000];
	private volatile int size = 0;
	private volatile int head = 0;
	private volatile int tail = 0;
	
	public void put(int value) throws InterruptedException {
		synchronized (this) {
		// 此处最好使⽤ while.
		// 否则 notifyAll 的时候, 该线程从 wait 中被唤醒,
		// 但是紧接着并未抢占到锁. 当锁被抢占的时候, 可能⼜已经队列满了
		// 就只能继续等待
			while (size == items.length) {
				wait();
			}
			items[tail] = value;
			tail = (tail + 1) % items.length;
			size++;
			notifyAll();
		}
	}
	
	public int take() throws InterruptedException {
		int ret = 0;
		synchronized (this) {
			while (size == 0) {
				wait();
			}
			ret = items[head];
			head = (head + 1) % items.length;
			size--;
			notifyAll();
		}
		return ret;
	}
	
	public synchronized int size() {
		return size;
	}
	
	// 测试代码
	public static void main(String[] args) throws InterruptedException {
		BlockingQueue blockingQueue = new BlockingQueue();
		Thread customer = new Thread(() -> {
		while (true) {
			try {
				int value = blockingQueue.take();
				System.out.println(value);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}, "消费者");	
	
		customer.start();
		Thread producer = new Thread(() -> {
			Random random = new Random();
				while (true) {					try {
						blockingQueue.put(random.nextInt(10000));
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}, "生产者");
			
		producer.start();
		customer.join();
		producer.join();
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

Resumir

1. A fila de bloqueio é equivalente a um buffer, equilibrando as capacidades de processamento de produtores e consumidores (recorte e preenchimento de pico).
2. O bloqueio de filas também pode dissociar produtores e consumidores.