Technology sharing

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

obturans queue

1. conceptus

Interclusio queue est speciale genus queue.

Queue interclusio in filo tuto data structuram esse potest et has notas sequentes habet:

• Cum plena queue sit, pergens ad queue obstruet donec alia fila elementa a queue accipiant..
• Cum queue vacua est, usque ad dequeue etiam obstruet, donec alia fila elementa in queue inserantur.

Typical applicatio missionis interclusionis queue est "exemplatoris dolor producentis"
producentis

Exemplar consumptorium solvit problema validum copulationis inter effectrix et consumers per vas.

Procuratores et perussi non directe inter se communicant, sed per interclusionem queues communicant. Ergo post operante notitia producit, non opus est ut dolor ut aliquid exspectet, sed directe mittit ad interclusionem queue Non quaerit producentem pro notitia.

Gradus maioris momenti sunt in exsecutione exemplar producentis dolor.

1. deducendi producentis
2. animadverto dolor

2. Clausus queue in bibliotheca vexillum

Interclusio queue in bibliotheca vexillum Javae aedificata est. Si opus est ut queues in quibusdam programmatis interclusionibus utamur, recta obstantia queue in bibliotheca vexillum uti possumus.
Can.

• ClaususQueue est interface
• Modus ponitur modus ad ingressum queue claudendi, et capiendi modus adhibendus est exitus queue claudendi.
• BlockingQueue etiam modos habet ut offerunt, capita, et peek, sed rationes non habent interclusio notas.

Pseudo codicei interclusionis queue talis est:

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

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

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

3. producentis dolor exemplar

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. Clausus queue implementation

1. Hoc fit per modum "queue circularis".
2. Utere synchronised pro densis imperium.
3. Cum ponatur elementa inserens, determinat si queue plena est et expectat.
4. Cum elementum sumit, determinat si queue vacua est et expectat.

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

Summatim

1. Interclusio queue aequipollet quiddam, ac facultates processui effectrix et consumendi aequans.
2. Clausus queues decouple effectrix etiam et consumerent.