Synchronized實現?

import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors;public class Pool {private int MAX;private int cnt = 0;private Pool(int MAX) {this.MAX = MAX;}private synchronized void produce() throws InterruptedException {for (int i = 0; i < 20; i++) {while (cnt == MAX) {wait();}System.out.println(Thread.currentThread().getName()+" PRODUCE "+ ++cnt);notifyAll();}}private synchronized void consume() throws InterruptedException {for (int i = 0; i < 20; i++) {while (cnt == 0) {wait();}System.out.println(Thread.currentThread().getName()+" CONSUME " + --cnt);notifyAll();}}public static void main(String[] args) {final Pool pool = new Pool(6);ExecutorService executor = Executors.newCachedThreadPool();executor.execute(new Runnable() {@Overridepublic void run() {try {pool.consume();} catch (InterruptedException e) {e.printStackTrace();}}});executor.execute(new Runnable() {@Overridepublic void run() {try {pool.produce();} catch (InterruptedException e) {e.printStackTrace();}}});executor.shutdown();} }

ReentrantLock

import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.ReentrantLock;public class Pool {private int MAX;private int cnt = 0;private ReentrantLock lock = new ReentrantLock();private Condition full = lock.newCondition();private Condition empty = lock.newCondition();private Pool(int MAX) {this.MAX = MAX;}private void produce() throws InterruptedException {for (int i = 0; i < 20; i++) {lock.lock();while (cnt == MAX) {full.await();}System.out.println(Thread.currentThread().getName()+" PRODUCE "+ ++cnt);empty.signalAll();lock.unlock();}}private void consume() throws InterruptedException {for (int i = 0; i < 20; i++) {lock.lock();while (cnt == 0) {empty.await();}System.out.println(Thread.currentThread().getName()+" CONSUME "+ --cnt);full.signalAll();lock.unlock();}}public static void main(String[] args) {final Pool pool = new Pool(6);ExecutorService executor = Executors.newCachedThreadPool();executor.execute(new Runnable() {@Overridepublic void run() {try {pool.consume();} catch (InterruptedException e) {e.printStackTrace();}}});executor.execute(new Runnable() {@Overridepublic void run() {try {pool.produce();} catch (InterruptedException e) {e.printStackTrace();}}});executor.shutdown();} }

結果都為、

pool-1-thread-2 PRODUCE 1 pool-1-thread-2 PRODUCE 2 pool-1-thread-2 PRODUCE 3 pool-1-thread-2 PRODUCE 4 pool-1-thread-2 PRODUCE 5 pool-1-thread-2 PRODUCE 6 pool-1-thread-1 CONSUME 5 pool-1-thread-1 CONSUME 4 pool-1-thread-1 CONSUME 3 pool-1-thread-1 CONSUME 2 pool-1-thread-1 CONSUME 1 pool-1-thread-1 CONSUME 0 pool-1-thread-2 PRODUCE 1 pool-1-thread-2 PRODUCE 2 pool-1-thread-2 PRODUCE 3 pool-1-thread-2 PRODUCE 4 pool-1-thread-2 PRODUCE 5 pool-1-thread-2 PRODUCE 6 pool-1-thread-1 CONSUME 5 pool-1-thread-1 CONSUME 4 pool-1-thread-1 CONSUME 3 pool-1-thread-1 CONSUME 2 pool-1-thread-1 CONSUME 1 pool-1-thread-1 CONSUME 0 pool-1-thread-2 PRODUCE 1 pool-1-thread-2 PRODUCE 2 pool-1-thread-2 PRODUCE 3 pool-1-thread-2 PRODUCE 4 pool-1-thread-2 PRODUCE 5 pool-1-thread-2 PRODUCE 6 pool-1-thread-1 CONSUME 5 pool-1-thread-1 CONSUME 4 pool-1-thread-1 CONSUME 3 pool-1-thread-1 CONSUME 2 pool-1-thread-1 CONSUME 1 pool-1-thread-1 CONSUME 0 pool-1-thread-2 PRODUCE 1 pool-1-thread-2 PRODUCE 2 pool-1-thread-1 CONSUME 1 pool-1-thread-1 CONSUME 0

銀行家算法：?

為了實現銀行家算法，需要定義一下幾個數據結構，n表示系統進程的個數，m表示資源類型的種類：

• available[i]——代表i資源現有的數量。
• max[n][m]——n*m矩陣，n進程對于m資源的最大需求量。
• allocation[n][m]——n*M矩陣，n進程現在已經分配的m資源的實例數量。
• need[n][m]——n*m矩陣，n進程還需要m資源的數量。

1、安全性算法

目的：確定計算機系統是否處于安全狀態的算法分為一下幾個步驟：

（1）設work[n]和finish[m]，進行初始化，work[i]=available[i]，finish[i]=false；i=0,1,...n-1；work代表i資源現有的數量。finish[i]=false代表進程i不滿足要求。

（2）查找這樣的i，使其滿足

finish[i]=false；

need[i]<=work[i];? ? //注意這里比較的是整行的資源，不是單獨的資源。

如果沒有這樣的i存在，則轉到（4）

（3）設進程獲得資源，可順利執行，直至完成，從而釋放資源。

work[i]=work[i]+allocation[i];?

finish[i]=true;

返回到第（2）步

（4）如果對所有的i，finish[i]=true；那么系統處于安全狀態。

上述算法的復雜度為m*n^2；

其實上述算法就是假設釋放一個進程，然后在找一個能在剩余可用資源中完成請求的進程，重復操作。我們的目標是找一個安全序列，因此上述算法可能要嘗試多次。只要能找到一個安全序列，那么系統就處于安全狀態。

2、資源請求算法

現在，描述如何判斷是否可安全允許請求的算法；

設request[i]為進程i的請求向量，因此該向量的長度為m；當進程i做出請求時，采取如下動作：

如果request[i]<=need[i]；那么轉到第 2 步，否則產生出錯條件，這是因為超出了最大請求。

如果request[i]<=available[i]；那么轉到第 3 步，否則產生出錯，這是因為沒有可用資源。

假定系統可以分配給進程pi所請求的資源，那么按照如下形式修改狀態：

• available[i]=available[i] - request[i];
• allocation[i]=allocation[i] + request[i];
• need[i]=need[i] -?request[i];

判斷如果產生的資源分配狀態是安全的，那么交易完成且進程i可以分配到所請求的資源，如果不安全，那么進程i必須等待request[i] 并恢復到原來資源分配狀態。

總結

以上是生活随笔為你收集整理的多线程—生产者消费者模式、银行家算法的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。