2. 程式人生 > >移動端多執行緒程式設計高階篇-哲學家吃飯問題

移動端多執行緒程式設計高階篇-哲學家吃飯問題

阿新 • • 發佈：2019-01-16

1.哲學家就餐問題問題描述

 


2.原始碼描述

public class DemoPhil {
	volatile public List<ReentrantLock> mLocks = new ArrayList<ReentrantLock>();
	List<Philosopher> mList = new ArrayList<Philosopher>();
	private Object obj = new Object();
	
	public DemoPhil() {
		for(int i = 0;i < 4;i++){
			mLocks.add(new ReentrantLock());
		}
		//四個哲學家
		mList.add(new Philosopher(2,"餃子",1));
		mList.add(new Philosopher(1,"刀削麵",2));
		mList.add(new Philosopher(2,"回鍋肉",3));
		mList.add(new Philosopher(2,"米飯",4));
		
		// TODO Auto-generated constructor stub
		for(int i = 0;i < 4;i++){
			final int index = i;
			Thread thread = new Thread("tName-" + i){
				@Override
				public void run() {
					super.run();
					final Philosopher philosopher = mList.get(index);
					while(true){
						if(philosopher.cnt >= philosopher.MAX_CNT){
							System.out.println("==============================================");
							break;
						}else{
							//嘗試獲取左邊筷子
							int leftIndex = index;
							int rightIndex = index + 1;
							//右邊筷子
							if(rightIndex >= mList.size()){
								rightIndex = 0;
							}
							ReentrantLock leftChopStrick = mLocks.get(leftIndex);
							ReentrantLock rightChopStrick = mLocks.get(rightIndex);
							System.out.println("哲學家"+philosopher.number+"嘗試鎖定筷子" + leftIndex + "," + rightIndex + "");
							if(!leftChopStrick.isLocked() && !rightChopStrick.isLocked()){
								System.out.println("哲學家"+philosopher.number+"鎖定筷子" + leftIndex + "," + rightIndex + "成功...");
								leftChopStrick.lock();
								rightChopStrick.lock();
								try{
									try {
										System.out.println("哲學家" + philosopher.number + " 正在吃" + philosopher.eatSth + " 需要時間:" + (philosopher.eatTime/1000) + "秒");
										Thread.sleep(philosopher.eatTime);
										philosopher.cnt++;
									} catch (InterruptedException e) {
										e.printStackTrace();
									}
								}finally{
									leftChopStrick.unlock();
									rightChopStrick.unlock();
									synchronized (obj) {
										obj.notifyAll();
									}
								}
							}else{
								synchronized (obj) {
									try {
										System.out.println("哲學家" + philosopher.number + " 沒有鎖定筷子成功，等待中...");
										obj.wait();
									} catch (InterruptedException e) {
										e.printStackTrace();
									}
									System.out.println("哲學家" + philosopher.number + " 由等待筷子中被喚醒...");
								}
							}
						}
					}
					System.out.println("哲學家" + philosopher.number + "已經次完飯啦~");
				}
			};
			thread.start();
		}
	}
	
	public class Philosopher{
		public long eatTime;	//吃飯時間
		public String eatSth;	//吃飯食物
		public int number;		//哲學家編號
		public int cnt;			//吃幾碗飯
		public final int MAX_CNT = 3;
		
		public Philosopher(int eatTime,String eatSth,int number){
			this.eatTime = eatTime * 1000;
			this.eatSth = eatSth;
			this.number = number;
		}
	}

	
	public static void main(String[] args) {
		new DemoPhil();
	}
}

執行結果:

哲學家1嘗試鎖定筷子0,1
哲學家1鎖定筷子0,1成功...
哲學家1 正在吃餃子 需要時間:2秒
哲學家3嘗試鎖定筷子2,3
哲學家3鎖定筷子2,3成功...
哲學家3 正在吃回鍋肉 需要時間:2秒
哲學家4嘗試鎖定筷子3,0
哲學家4 沒有鎖定筷子成功，等待中...
哲學家2嘗試鎖定筷子1,2
哲學家2 沒有鎖定筷子成功，等待中...
哲學家2 由等待筷子中被喚醒...
哲學家2嘗試鎖定筷子1,2
哲學家2 沒有鎖定筷子成功，等待中...
哲學家4 由等待筷子中被喚醒...
哲學家4嘗試鎖定筷子3,0
哲學家4 沒有鎖定筷子成功，等待中...
哲學家1嘗試鎖定筷子0,1
哲學家1鎖定筷子0,1成功...
哲學家1 正在吃餃子 需要時間:2秒
哲學家3嘗試鎖定筷子2,3
哲學家3鎖定筷子2,3成功...
哲學家3 正在吃回鍋肉 需要時間:2秒
哲學家4 由等待筷子中被喚醒...
哲學家4嘗試鎖定筷子3,0
哲學家4 沒有鎖定筷子成功，等待中...
哲學家2 由等待筷子中被喚醒...
哲學家2嘗試鎖定筷子1,2
哲學家2 沒有鎖定筷子成功，等待中...
哲學家2 由等待筷子中被喚醒...
哲學家2嘗試鎖定筷子1,2
哲學家2 沒有鎖定筷子成功，等待中...
哲學家1嘗試鎖定筷子0,1
哲學家1鎖定筷子0,1成功...
哲學家1 正在吃餃子 需要時間:2秒
哲學家4 由等待筷子中被喚醒...
哲學家4嘗試鎖定筷子3,0
哲學家4 沒有鎖定筷子成功，等待中...
哲學家4 由等待筷子中被喚醒...
哲學家4嘗試鎖定筷子3,0
哲學家4 沒有鎖定筷子成功，等待中...
哲學家2 由等待筷子中被喚醒...
哲學家2嘗試鎖定筷子1,2
哲學家2 沒有鎖定筷子成功，等待中...
哲學家3嘗試鎖定筷子2,3
哲學家3鎖定筷子2,3成功...
哲學家3 正在吃回鍋肉 需要時間:2秒
==============================================
哲學家1已經次完飯啦~
哲學家2 由等待筷子中被喚醒...
哲學家2嘗試鎖定筷子1,2
哲學家4 由等待筷子中被喚醒...
哲學家4嘗試鎖定筷子3,0
哲學家2 沒有鎖定筷子成功，等待中...
哲學家4 沒有鎖定筷子成功，等待中...
==============================================
哲學家4 由等待筷子中被喚醒...
哲學家4嘗試鎖定筷子3,0
哲學家4鎖定筷子3,0成功...
哲學家3已經次完飯啦~
哲學家4 正在吃米飯 需要時間:2秒
哲學家2 由等待筷子中被喚醒...
哲學家2嘗試鎖定筷子1,2
哲學家2鎖定筷子1,2成功...
哲學家2 正在吃刀削麵 需要時間:1秒
哲學家2嘗試鎖定筷子1,2
哲學家2鎖定筷子1,2成功...
哲學家2 正在吃刀削麵 需要時間:1秒
哲學家2嘗試鎖定筷子1,2
哲學家2鎖定筷子1,2成功...
哲學家2 正在吃刀削麵 需要時間:1秒
哲學家4嘗試鎖定筷子3,0
哲學家4鎖定筷子3,0成功...
哲學家4 正在吃米飯 需要時間:2秒
==============================================
哲學家2已經次完飯啦~
哲學家4嘗試鎖定筷子3,0
哲學家4鎖定筷子3,0成功...
哲學家4 正在吃米飯 需要時間:2秒
==============================================
哲學家4已經次完飯啦~

相關推薦

移動端多執行緒程式設計高階篇-哲學家吃飯問題

1.哲學家就餐問題問題描述   2.原始碼描述 public class DemoPhil { volatile public List<ReentrantLock> mLocks = new ArrayList<ReentrantLock>(

windows C++多執行緒程式設計高階篇 實現執行緒同步

    上一篇文章windows程式設計 使用C++實現多執行緒類僅僅是介紹了怎樣用類來實現多執行緒，這篇文章則重點介紹多執行緒中資料同步的問題。好了，廢話不多說，進入主題。     問題場景：這裡我們假設有這樣一個工作流水線(CWorkPipeline)，它不斷的生成一

多執行緒程式設計——基礎篇 （一）

　　[寫在前面] 　　隨著計算機技術的發展，程式設計模型也越來越複雜多樣化。但多執行緒程式設計模型是目前計算機系統架構的最終模型。隨著CPU主頻的不斷攀升，X86架構的硬體已經成為瓶，在這種架構的CPU主頻最高為4G。事實上目前3.6G主頻的CPU已經接近了頂峰。 　　如果不

多執行緒程式設計 基礎篇 (一)

基礎篇 (一)[寫在前面]    隨著計算機技術的發展,程式設計模型也越來越複雜多樣化.但多執行緒程式設計模型是目前計算機系統架構的最終模型.隨著CPU主頻的不斷攀升,X86架構的硬體已經成為瓶,在這種架構的CPU主頻最高為4G.事實上目前3.6G主頻的CPU已經接近了頂峰.

併發多執行緒之死鎖-----哲學家吃飯問題

該例子說明了4點出現死鎖需要同時滿足的條件： 互斥條件：任務使用的資源至少有一個是不能共享的。這裡，一根chopstick(筷子)一次就只能讓一個philosopher(哲學家)使用。 至少有一個任務它必須持有一個資源且正在等待獲取另一個當前被別的任務持有的

Python多執行緒程式設計,執行緒鎖,以及補充上一篇多程序文章

程序補充 程序間的訊號 訊號是唯一的非同步通訊方法 一個程序向另一個程序傳送一個訊號來傳遞某種資訊，接受者根據傳遞的資訊來做相應的事 $ kill -l檢視系統訊號說明 $ kill -9 pid號對程序傳送訊號 訊號名稱 說明

【搞定Java併發程式設計】第3篇：多執行緒概述~上篇

上一篇：併發基礎概述：https://blog.csdn.net/pcwl1206/article/details/84833911 目  錄： 1、什麼是執行緒 2、執行緒的建立 2.1、Thread和Runnable簡介 2.2、Thread和Runnable的異同

【新聞】本人新書《Java多執行緒程式設計實戰指南（核心篇）》已出版上市

豆瓣主頁 購買連結 試讀下載 （待補充） 原始碼下載 內容簡介 隨著現代處理器的生產工藝從提升處理器主頻頻率轉向多核化，即在一塊晶片上整合多個處理器核心（Core），多核處理器（Multicore Proc

linux基礎程式設計 套接字socket 完整的伺服器端多執行緒socket程式

此段程式來自我的一個專案中，稍微做了些修改，執行穩定，客戶端程式比較簡單所以未編寫，可以用socket除錯工具測試此段程式碼 費話不多說，直接上程式碼 #include<stdlib.h> #include<stdio.h> #include&

LinuxC多執行緒程式設計第五篇：執行緒通訊(Condition)

        執行緒同步還有一種情況，執行緒1需要等某個條件成立才能繼續往下執行，如果這個條件不成立，執行緒1就阻塞等待，執行緒2在執行某個條件成立了就喚醒執行緒1。這個和Java中的wait()和notify()其實是一樣的 初始化與銷燬通訊條件 #include &

Java多執行緒程式設計實戰指南（核心篇）讀書筆記（四）

博主準備惡補一番Java高併發程式設計相關知識，接下來將閱讀該書，並且進行比較詳細的總結，好記性不如爛筆頭，加油。Java多執行緒程式設計實戰指南（核心篇）讀書筆記（四），主要記錄該書第七章和第八章的基

網路程式設計：服務端處理多個客戶端----多執行緒實現、建立執行緒特有資料.

重點集中在用多執行緒實現，建立執行緒特有資料,不會發生資料寫入衝突。實現的功能很簡單，客戶端連線成功後，輸入一個整數，服務端返回它的二進位制形式。客戶端輸入0，則主動退出。三個檔案： duoxianc.c ，主檔案binarykey.c，執行緒執行函式及特有資料建立clien

socket C/C++程式設計（8）server端多執行緒處理clients佇列

1. 採用C++11的標準執行緒庫(linux之pthread為例)實現多執行緒(test.cpp) #include <stdio.h> #include <string.h> #ifdef WIN32 #include

43、併發程式設計之多執行緒實操篇

### 一 threading模組介紹 multiprocessing模組完全模仿了threading模組的介面，二者在使用層面，有很大的相似性，因而不再詳細介紹 [官網連結：https://docs.python.org/3/library/threading.html?highlight=thread

Java多執行緒程式設計中執行緒的同步與互斥/執行緒安全/Java鎖

摘要：多執行緒三個特徵:原子性、可見性以及有序性.&gt;執行緒的同步與互斥?(同步執行緒與非同步執行緒,執行緒同步和非同步問題)&nbsp;&nbsp;1.同步:假設現有執行緒A和執行緒B,執行緒A需要往緩衝區寫資料,執行緒B需要從緩衝區讀資料,但他們之間存在一種制約

Linux多執行緒程式設計---執行緒間同步（互斥鎖、條件變數、訊號量和讀寫鎖）

本篇博文轉自http://zhangxiaoya.github.io/2015/05/15/multi-thread-of-c-program-language-on-linux/ Linux下提供了多種方式來處理執行緒同步，最常用的是互斥鎖、條件變數、訊號量和讀寫鎖。  下面是思維導

java多執行緒程式設計詳細入門教程

##1、概念      執行緒是jvm排程的最小單元，也叫做輕量級程序，程序是由執行緒組成，執行緒擁有私有的程式技術器以及棧，並且能夠訪問堆中的共享資源。這裡提出一個問題，為什麼要用多執行緒？有一下幾點，首先，隨著cpu核心數的增加，計算機硬

Python Threading 多執行緒程式設計

寫在篇前   threading模組是python多執行緒處理包，使用該模組可以很方便的實現多執行緒處理任務，本篇文章的基礎是需要掌握程序、執行緒基本概念，對PV原語、鎖等傳統同步處理方法有一定的瞭解。另外，threading模組的實現是參考java多執行緒處理方式，並且只實現了其中的一

MFC多執行緒程式設計實踐總結之AfxBeginThread()

在MFC多執行緒程式設計中，執行緒函式呼叫類內成員變數和成員函式的步驟： 1.將執行緒函式在類.h檔案中類內宣告，並用修飾符static修飾； class CtestDlg : public CDialogEx {    public:    &nbs

DEVOPS-01多程序、多執行緒程式設計

一、多執行緒程式設計 1.1 forking工作原理 1.1.1 什麼是forking 1. fork(分岔)在Linux系統中使用非常廣泛 2.  當某一命令執行時,父程序(當前程序)fork出一個子程序 3.  父程序將自身資源拷貝一份,命令在子程序中執行時,就具