2. 程式人生 > >訊號量解決經典執行緒同步問題

訊號量解決經典執行緒同步問題

阿新 • • 發佈：2019-01-27
       訊號量 是E. W.Dijkstra在l965年提出的一種方法，它使用一個整型變數來累計喚醒次數，以供以後使用。在他的建議中引入一個新的變號型別，稱作訊號量(semapore )。一個訊號量的值可以為0,表示沒有積累下來的喚醒操作;或者為正值，表示有一個或多個被積累下來的喚醒操作。
      Dijkstra建議設兩種操作:Down和Up。對一訊號量執行Down操作是檢查其值是否大於0;若是則將其值減1(即用掉一個儲存的喚醒訊號)並繼續。若值為0,則程序將睡眠，而且此時Down操作並未結束。檢查數值，改變數值以及可能發生的睡眠操作均作為一個單一的、不可分割的原子操作(atomic action)完成。即保證一旦一個訊號量操作開始，則在操作完成或阻塞之前別的程序均不允許訪問該訊號量。這種原子性對於解決同步間題和避免競爭條件是非常重要的。
      Up操作遞增訊號量的值。如果一個或多個程序在該訊號量上睡眠，無法完成一個先前的Down操作、則由系統選擇其中的一個(例如，隨機挑選)並允許其完成它的Down操作。於是，對一個有程序在其上睡眠的訊號量執行一次Up操作之後，該訊號量的值仍舊是0.但在其上睡眠的程序卻少了一個。遞增訊號量的值和喚醒一個程序同樣也是不可分割的。不會有程序因執行Up而阻塞。

  
      JDK的併發包就給我提供了一個類似的訊號量類——Semaphore ，其中的acquire()和release()方法就相當於Down和Up操作，這兩個方法的特殊之處在於對Semaphore物件的操作都是原子操作，由作業系統底層來支援。下面我們講的四種經典執行緒同步問題，都是使用了Java編碼。

1、生產者-消費者問題
  
   由一個大小固定的倉庫，生產者將生產的產品放入倉庫，如果倉庫滿，則生成者被阻塞。消費者將倉庫中的產品拿出來消耗，如果倉庫空，則消費者被阻塞。

Java程式碼：
import java.util.concurrent.Semaphore;

class Signs{
      static Semaphore empty=new Semaphore(10); //訊號量：記錄倉庫空的位置
    static Semaphore full=new Semaphore(0);   //訊號量：記錄倉庫滿的位置
    static Semaphore mutex=new Semaphore(1);  //臨界區互斥訪問訊號量(二進位制訊號量)，相當於互斥鎖。
}
class Producer implements Runnable{
	
      public void run(){
           try {
                  while(true){
                         Signs.empty.acquire(); //遞減倉庫空訊號量
	      Signs.mutex.acquire(); //進入臨界區
	      System.out.println("生成一個產品放入倉庫");
	         Signs.mutex.release(); //離開臨界區
	      Signs.full.release();  //遞增倉庫滿訊號量
	      Thread.currentThread().sleep(100);
	  }
           } catch (InterruptedException e) {
	    e.printStackTrace();
           }
      }
}
class Consumer implements Runnable{
       public void run(){
            try {
                 while(true){
	       Signs.full.acquire(); //遞減倉庫滿訊號量
	     Signs.mutex.acquire();
	       System.out.println("從倉庫拿出一個產品消費");
	       Signs.mutex.release();
	       Signs.empty.release(); //遞增倉庫空訊號量
	     Thread.currentThread().sleep(1000);
	  }
            } catch (InterruptedException e) {
	   e.printStackTrace();
            }
       }
	
}
public class Test{

	public static void main(String[] args) {
		new Thread(new Producer()).start();
		new Thread(new Consumer()).start();
	}
}

2、哲學家進餐問題

      在1965年，Dijkstra提出並解決了一個他稱之為哲學家進餐的同步問題。從那時起，每個發明新的同步原語的人都希望通過解決哲學家進餐間題來展示其同步原語的精妙之處。這個問題可以簡單地描述：五個哲學家圍坐在一張圓桌周圍，每個哲學家面前都有一碟通心麵，由於麵條很滑，所以要兩把叉子才能夾住。相鄰兩個碟子之間有一把叉子。
      哲學家的生活包括兩種活動:即吃飯和思考。當一個哲學家覺得餓時，他就試圖去取他左邊和右邊的叉子。如果成功地獲得兩把叉子，他就開始吃飯，吃完以後放下叉子繼續思考。

Java程式碼 
import java.util.concurrent.Semaphore;

class Signs{
	final static int THINKING=0; //哲學家的狀態THINGING
	final static int EATING=1; //哲學家的狀態EATING
	static int[] status=new int[5]; //哲學家的狀態，預設都是THINGING
	static Semaphore[] s=null; //訊號量：記錄哲學家是否可以進餐，不能進餐則堵塞
	static Semaphore mutex=new Semaphore(1); //臨界區互斥訪問訊號量(二進位制訊號量)，相當於互斥鎖
	
	//初始化每個哲學家的進餐訊號量，預設值都不能進餐
	static{
		s=new Semaphore[5];
		for(int i=0;i<s.length;i++)
			s[i]=new Semaphore(0);
	};
}

class Philosopher implements Runnable{
	private int pid; //當前哲學家的序號
	private int lid; //坐在左手邊的哲學家序號
	private int rid; //坐在右手邊的哲學家序號
	
	Philosopher(int id){
		this.pid=id;
		this.lid=(id+4)%5;
		this.rid=(id+1)%5;
	}
	
	private void test(int pid){
		//如果當前哲學家左右手邊的人都沒有吃飯，則當前哲學家可以進餐
		if(Signs.status[pid]==Signs.THINKING&&Signs.status[lid]!=Signs.EATING&&Signs.status[rid]!=Signs.EATING){
			Signs.status[pid]=Signs.EATING; //此時當前哲學家執行緒可以進餐，但其他哲學家執行緒很可能無法進餐
			Signs.s[pid].release(); //釋放一個許可
		}
	}
	
	public void run(){
		try {
			//嘗試拿起叉子準備進餐
			Signs.mutex.acquire();
			test(pid);
			Signs.mutex.release();
				
			//判斷當前哲學家的進餐訊號量，如果不能許可進餐，則當前執行緒阻塞
			Signs.s[pid].acquire();
			System.out.println("#"+pid+" 號哲學家正在進餐...");
				
			//放下叉子，並喚醒旁邊兩個被阻塞進餐的哲學家，讓他們嘗試進餐
			Signs.mutex.acquire();
			Signs.status[pid]=Signs.THINKING;
			test(lid); //讓左手邊的哲學家嘗試拿起叉子，如果可以，則釋放這個哲學家的訊號量許可
			test(rid); //同上
			Signs.mutex.release();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	
}


public class Test{

	public static void main(String[] args) {
		new Thread(new Philosopher(0)).start();
		new Thread(new Philosopher(1)).start();
		new Thread(new Philosopher(2)).start();
		new Thread(new Philosopher(3)).start();
		new Thread(new Philosopher(4)).start();
	}
}

3、讀者-寫者問題
 
讀者一寫者問題(Courtois et al., 1971)為資料庫訪問建立了一個模型。例如，設想一個飛機定票系統，其中有許多競爭的程序試圖讀寫其中的資料。多個程序同時讀是可以接受的，但如果一個程序正在寫資料庫、則所有的其他程序都不能訪問資料庫，即使讀操作也不行。

Java程式碼 
import java.util.concurrent.Semaphore;

class Sign{
	static Semaphore db=new Semaphore(1); //訊號量：控制對資料庫的訪問
	static Semaphore mutex=new Semaphore(1); //訊號量：控制對臨界區的訪問
	static int rc=0; //記錄正在讀或者想要讀的程序數
}
class Reader implements Runnable{
	
	public void run(){
		try {
			//互斥對rc的操作
			Sign.mutex.acquire();
			Sign.rc++;  //又多了一個讀執行緒
			if(Sign.rc==1) Sign.db.acquire(); //如果是第一個讀程序開始讀取DB，則請求一個許可，使得寫程序無法操作DB
			Sign.mutex.release();
				
			//無臨界區控制，多個讀執行緒都可以操作DB
			System.out.println("[R]   "+Thread.currentThread().getName()+": read data....");
			Thread.sleep(100);
			
			//互斥對rc的操作
			Sign.mutex.acquire();
			Sign.rc--;
			if(Sign.rc==0) Sign.db.release(); //如果最後一個讀程序讀完了，則釋放許可，讓寫程序有機會操作DB
			Sign.mutex.release();

		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}
class Writer implements Runnable{
	
	public void run(){
		try {
			//與讀操作互斥訪問DB
			Sign.db.acquire();
			System.out.println("[W]   "+Thread.currentThread().getName()+": write data....");
			Thread.sleep(100);
			Sign.db.release();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	
	}
}
public class Test {

	public static void main(String[] args){
		new Thread(new Reader()).start();
		new Thread(new Reader()).start();
		new Thread(new Writer()).start();
	}
}

4、理髮師問題

      另一個經典的問題發生在理髮店裡。理髮店裡有一位理髮師，一把理髮椅和n把供等候理髮的顧客坐的椅子。如果沒有顧客，理髮師便在理髮椅上睡覺，當一個顧客到來時，他必須先叫醒理髮師，如果理髮師正在理髮時又有顧客來到，則如果有空椅子可坐，他們就坐下來等;如果沒有空椅子，他就離開。

Java程式碼： 
</pre><pre class="java" name="code">import java.util.concurrent.Semaphore;

class Sign{
	final static int CHAIRS=5; //椅子數量
	static int waiting=0; //等待理髮的顧客數
	static Semaphore consumers=new Semaphore(0); //訊號量：等候服務的顧客數
	static Semaphore barber=new Semaphore(0);  //訊號量：等待顧客的理髮師數
	static Semaphore mutex=new Semaphore(1); //訊號量：控制對臨界區的訪問
}

class Barber implements Runnable{
	
	public void run(){
		try {
			while(true){
				Sign.consumers.acquire(); //如果顧客數是0，則理髮師睡覺
				//互斥操作顧客等待waiting
				Sign.mutex.acquire();
				Sign.waiting--; 
				Sign.barber.release(); //一個理髮師現在開始理髮
				Sign.mutex.release();
				System.out.println("理髮師"+Thread.currentThread().getName()+"正在理髮...");
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

class Customer implements Runnable{
	
	public void run(){
		try {
			//互斥操作顧客等待waiting
			Sign.mutex.acquire();
			//如果還有椅子空餘，則顧客坐在椅子上等待
			if(Sign.waiting<Sign.CHAIRS){
				Sign.waiting++;
				Sign.consumers.release(); //顧客理
				Sign.mutex.release();
				Sign.barber.acquire(); //如果理髮師數量為0，則顧客等待
				System.out.println("顧客"+Thread.currentThread().getName()+"正在被理髮...");
			}else{
				Sign.mutex.release(); //理髮店滿人，顧客走人
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	
	}
}


public class Test {

	public static void main(String[] args){
		new Thread(new Barber()).start();
		new Thread(new Customer()).start();
		new Thread(new Customer()).start();
		new Thread(new Customer()).start();
	}
}

相關推薦

訊號量解決經典執行緒同步問題

       訊號量 是E. W.Dijkstra在l965年提出的一種方法，它使用一個整型變數來累計喚醒次數，以供以後使用。在他的建議中引入一個新的變號型別，稱作訊號量(semapore )。一個訊號量的值可以為0,表示沒有積累下來的喚醒操作;或者為正值，表示有一個或多個

秒殺多執行緒第八篇 經典執行緒同步 訊號量Semaphore

前面介紹了關鍵段CS、事件Event、互斥量Mutex在經典執行緒同步問題中的使用。本篇介紹用訊號量Semaphore來解決這個問題。 首先也來看看如何使用訊號量，訊號量Semaphore常用有三個函式，使用很方便。下面是這幾個函式的原型和使用說明。 第一個 Create

秒殺多執行緒第九篇 經典執行緒同步總結 關鍵段 事件 互斥量 訊號量

                前面《秒殺多執行緒第四篇一個經典的多執行緒同步問題》提出了一個經典的多執行緒同步互斥問題，這個問題包括了主執行緒與子執行緒的同步，子執行緒間的互斥，是一道非常經典的多執行緒同步互斥問題範例，後面分別用了四篇來詳細介紹常用的執行緒同步互斥機制——關鍵段、事件、互斥量、訊號量。下面

秒殺多執行緒第七篇 經典執行緒同步 互斥量Mutex

閱讀本篇之前推薦閱讀以下姊妹篇： 《秒殺多執行緒第四篇一個經典的多執行緒同步問題》 《秒殺多執行緒第五篇經典執行緒同步關鍵段CS》 《秒殺多執行緒第六篇經典執行緒同步事件Event》   前面介紹了關鍵段CS、事件Event在經典執行緒同步問題中的使用。本篇介紹用互斥量Mu

秒殺多執行緒第五篇 經典執行緒同步 關鍵段CS

                上一篇《秒殺多執行緒第四篇 一個經典的多執行緒同步問題》提出了一個經典的多執行緒同步互斥問題，本篇將用關鍵段CRITICAL_SECTION來嘗試解決這個問題。本文首先介紹下如何使用關鍵段，然後再深層次的分析下關鍵段的實現機制與原理。關鍵段CRITICAL_SECTION一共就

C++ 經典執行緒同步 事件Event示例解析(十)

下面給個多執行緒案例使用event #define _CRT_SECURE_NO_WARNINGS #include <windows.h> #include <process.h> #include <stdio.h> struc

linux多執行緒程式設計(C)：訊號量實現的執行緒安全佇列

用訊號量實現的執行緒安全佇列。 簡單有用的示例程式， 比起互斥量的實現在多執行緒時效率更好。 cir_queue.h /* * \File * cir_queue.h * \Brief * circular queue */#ifndef __CIR_QUEUE_H_

day 32 管道,訊號量,程序池,執行緒的建立

1.管道(瞭解) Pipe():  在程序之間建立一條通道,並返回元組(conn1,conn2),其中conn1,conn2表示管道兩端的連線物件,強調一點:必須在產生Process物件之前產生管道. from multiprocessing import Process,Pi

linux基礎——經典執行緒同步問題解析及程式設計實現

前兩天寫了個簡單的執行緒池，結果在處理執行緒的同步互斥上花了不少時間，覺得有必要把以前學習的知識再過一遍，這次主要複習的是幾個非常經典的同步互斥問題。 一、生產者消費者問題 問題描述： 只有緩衝

秒殺多執行緒第五篇---經典執行緒同步 關鍵段（臨界區）CS

上一篇《秒殺多執行緒第四篇 一個經典的多執行緒同步問題》提出了一個經典的多執行緒同步互斥問題，本篇將用關鍵段CRITICAL_SECTION來嘗試解決這個問題。 本文首先介紹下如何使用關鍵段，然後再深層次的分析下關鍵段的實現機制與原理。 關鍵段CRITICA

java中的互斥鎖,訊號量和多執行緒等待機制

互斥鎖和訊號量都是作業系統中為併發程式設計設計基本概念，互斥鎖和訊號量的概念上的不同在於，對於同一個資源，互斥鎖只有0和1 的概念，而訊號量不止於此。也就是說，訊號量可以使資源同時被多個執行緒訪問，而互斥鎖同時只能被一個執行緒訪問 互斥鎖在java中的實現就是 Reetr

Java訊號量控制多執行緒併發

package com.uusafe.thread2;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.S

使用訊號量解決兩個執行緒同步問題

1.同步問題 我們知道多道程式設計理念的提出，使得執行緒（程序）和執行緒（程序）之間可以併發執行，但是有一些特殊的情況，請看下面的例子： (https://img-blog.csdn.net/20170126160159642?watermar

【Windows原理】執行緒同步-訊號量

#include "stdafx.h" #include <windows.h> int g_num = 0; HANDLE g_hSemaphore = nullptr; DWORD WINAPI ThreadProc(LPVOID lpParam) { for

19.執行緒同步：訊號量—>[單生產者/單消費者]單鏈表的插入和刪除

1.訊號量 1.訊號量本質 訊號量是鎖，是一種升級的mutex 訊號量在初始化時，可以指定共享資源的數量 2.相關函式 #include<semaphore.h> //標頭檔案 sem_t sem; //訊號量型別 int sem_destroy(se

執行緒同步：互斥鎖，訊號量

同步概念： 當多個執行緒共享相同的一塊記憶體時（實際上在一個程序的各個執行緒之間，除了棧區的資料之外，其他的資料這幾個縣城之間都是相互共享的），需要確保每個執行緒看到一致的資料檢視。也就是說，這些執行緒在對資料進行操作時，應該是同步的，也就是說當一個執行緒正在操作一個數據時，其他執行緒無法同時對

Python並行程式設計(五)：執行緒同步之訊號量

1、基本概念       訊號量是由作業系統管理的一種抽象資料型別，用於在多執行緒中同步對共享資源的使用。本質上說，訊號量是一個內部資料，用於標明當前的共享資源可以有多少併發讀取。       同樣在threading中，訊號量有acquire和release兩個函式。       - 每當執行緒想要讀取關聯

Windows執行緒（七）使用互斥量無法解決執行緒同步問題

互斥量介面： 1.建立互斥量： HANDLE CreateMutex ( LPSECURITY_ATTRIBUTES lpMutexAttributes,//安全控制，一般為NULL BOOL bInitialOwner, //

執行緒同步總結--臨界區 事件 互斥量 訊號量

在WIN32中，同步機制主要有以下幾種： 臨界區(Critical section) 事件(Event); 互斥量(mutex); 訊號量(semaphore);   臨界區(Critical section) 臨界區（Cri

NET多執行緒同步方法詳解(五)：訊號量(Semaphore)

   訊號量就像一個夜總會：它有確切的容量，並被保鏢控制。一旦滿員，就沒有人能再進入，其他人必須在外面排隊。那麼在裡面離開一個人後，隊頭的人就可以進入。訊號量的建構函式需要提供至少兩個引數-現有的人數和最大的人數。 訊號