प्रौद्योगिकी साझेदारी

[सञ्चालनप्रणाली] कतारं तथा उत्पादक-उपभोक्तृप्रतिरूपं अवरुद्धयति

2024-07-12

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

कतारं अवरुद्ध्य

1. अवधारणा

अवरोधकपङ्क्तिः एकः विशेषप्रकारस्य पङ्क्तिः अस्ति यत् एतत् "first in, first out" इति सिद्धान्तस्य अपि अनुसरणं करोति ।

अवरोधकपङ्क्तिः थ्रेड्-सुरक्षितदत्तांशसंरचना भवितुम् अर्हति तथा च निम्नलिखितलक्षणं भवति ।

  • यदा पङ्क्तिः पूर्णा भवति तदा पङ्क्तिं प्रविष्टुं निरन्तरं यावत् अन्ये सूत्राः पङ्क्तौ तत्त्वानि न गृह्णन्ति तावत् अवरुद्धं करिष्यति ।.
  • यदा पङ्क्तिः रिक्तः भवति तदा पङ्क्तिविच्छेदनं निरन्तरं करणं अपि अवरुद्धं करिष्यति यावत् अन्ये सूत्राः पङ्क्तौ तत्त्वानि न निवेशयन्ति ।

कतारं अवरुद्ध्य एकं विशिष्टं अनुप्रयोगपरिदृश्यं "उत्पादक-उपभोक्तृप्रतिरूपम्" अस्ति
उत्पादकः

उपभोक्तृप्रतिरूपं उत्पादकानां उपभोक्तृणां च मध्ये दृढयुग्मसमस्यायाः समाधानं पात्रद्वारा करोति ।

उत्पादकाः उपभोक्ताश्च प्रत्यक्षतया परस्परं संवादं न कुर्वन्ति, अपितु अवरोधकपङ्क्तिद्वारा संवादं कुर्वन्ति अतः उत्पादकेन दत्तांशस्य उत्पादनानन्तरं उपभोक्तुः संसाधितुं प्रतीक्षायाः आवश्यकता नास्ति, अपितु प्रत्यक्षतया अवरोधकपङ्क्तौ क्षिपति उत्पादकं दत्तांशं न याचते तस्य स्थाने प्रत्यक्षतया अवरोधकपङ्क्तौ गृह्यते ।

उत्पादक-उपभोक्तृ-प्रतिरूपस्य कार्यान्वयनस्य द्वौ प्रमुखौ सोपानौ स्तः- १.

  1. कार्यान्वयन उत्पादक
  2. उपभोक्तृ साक्षात्क

2. मानकपुस्तकालये पङ्क्तिं अवरुद्ध्य

जावा मानकपुस्तकालये अवरुद्धपङ्क्तिः निर्मितः अस्ति यदि अस्माकं केषुचित् कार्यक्रमेषु अवरोधकपङ्क्तिः उपयोक्तव्या अस्ति तर्हि मानकपुस्तकालये अवरोधकपङ्क्तिः प्रत्यक्षतया उपयोक्तुं शक्नुमः ।
शक्नोति।

  • BlockingQueue एकः अन्तरफलकः अस्ति वास्तविकः कार्यान्वयनवर्गः LinkedBlockingQueue अस्ति
  • put मेथड् इत्यस्य उपयोगः कतारप्रवेशस्य अवरोधाय भवति, तथा च take मेथड् इत्यस्य उपयोगः कतारनिर्गमस्य अवरोधाय भवति ।
  • BlockingQueue इत्यत्र offer, poll, peek इत्यादीनि पद्धतयः अपि सन्ति, परन्तु एतेषु विधिषु blocking लक्षणं नास्ति ।

पङ्क्तिं अवरुद्ध्य छद्मसङ्केतः निम्नलिखितरूपेण अस्ति ।

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

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

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

3. उत्पादक-उपभोक्तृप्रतिरूपम्

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. कतारस्य कार्यान्वयनम् अवरुद्ध्य

  1. एतत् "वृत्तपङ्क्तिः" इति पद्धत्या सिद्ध्यति ।
  2. लॉकिंग नियन्त्रणार्थं synchronized इत्यस्य उपयोगं कुर्वन्तु ।
  3. यदा put एकं तत्त्वं सम्मिलितं करोति तदा एतत् निर्धारयति यत् पङ्क्तिः पूर्णा अस्ति वा प्रतीक्षां करोति वा (ध्यायन्तु यत् प्रतीक्षा लूप् मध्ये अवश्यं कर्तव्या। यदा एतत् जागृतं भवति तदा पङ्क्तिः पूर्णा न भवितुम् अर्हति यतोहि एकस्मिन् समये बहुविधाः सूत्राः जागरिताः भवितुम् अर्हन्ति। ) .
  4. यदा take तत्त्वं बहिः निष्कासयति तदा पङ्क्तिः रिक्तः अस्ति वा इति निर्धारयति, प्रतीक्षते च (इदं लूप् प्रतीक्षा अपि अस्ति) ।
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

सारांशं कुरुत

  1. अवरोधकपङ्क्तिः बफरस्य बराबरः भवति, उत्पादकानां उपभोक्तृणां च प्रसंस्करणक्षमतानां संतुलनं करोति (Peak clipping and filling) ।
  2. पङ्क्तयः अवरुद्ध्य उत्पादकान् उपभोक्तृन् च वियुग्मनं कर्तुं अपि शक्नोति ।