多线程—生产者消费者模式、银行家算法

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] 并恢复到原来资源分配状态。

多线程—生产者消费者模式、银行家算法相关推荐

java多线程-生产者消费者模式
进程定义: 进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位线程定义: 线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能 ...
并发编程（五）python实现生产者消费者模式多线程爬虫
并发编程专栏系列博客并发编程(一)python并发编程简介并发编程(二)怎样选择多线程多进程和多协程并发编程(三)Python编程慢的罪魁祸首.全局解释器锁GIL 并发编程(四)如何使用多线程, ...
【C++】多线程(链式、循环队列)实现生产者消费者模式
生产者消费者模式: 生产者消费者问题(英语:Producer-consumer problem),也称有限缓冲问题(英语:Bounded-buffer problem),是一个多线程同 ...
多线程终极模式：生产者-消费者模式
多线程de小事情导航不迷路: 程序.进程以及线程的爱恨情仇最简单实现多线程的方法(Thread) 简单易懂的多线程(通过实现Runnable接口实现多线程) 常用获取线程基本信息的方法(新手专属) ...
[19/04/11-星期四] 多线程_并发协作(生产者/消费者模式_2种解决方案(管程法和信号灯法))...
一.概念多线程环境下,我们经常需要多个线程的并发和协作.这个时候,就需要了解一个重要的多线程并发协作模型"生产者/消费者模式". Ø 什么是生产者? 生产者指的是负责生产数据的模 ...
java消费者生产者设计模式_java 多线程并发设计模式之四: 生产者消费者模式
生产者消费者模式是一个经典的多线程设计模式,其核心思想是:有两类线程和一个内存缓冲区或者队列, 一类线程发起任务,并提交到队列中.另一类线程用来处理这些任务,叫做消费者线程. 这两类线程进行通信的桥梁 ...
Java多线程学习三：有哪几种实现生产者消费者模式的方法
我们先来看看什么是生产者消费者模式,生产者消费者模式是程序设计中非常常见的一种设计模式,被广泛运用在解耦.消息队列等场景.在现实世界中,我们把生产商品的一方称为生产者,把消费商品的一方称为消费者,有时 ...
多线程-并发编程(7)-生产者消费者模式及非阻塞队列与阻塞队列实现
生产者消费者模式是一个十分经典的多线程协作模式弄懂生产者消费者问题能够让我们对多线程编程的理解更加深刻存在3个元素 1.生产者(类比厨师) 2.生产者的生产产品(类比美食) 3.消费者(类比吃货) ...
Java多线程（含生产者消费者模式详解）
多线程导航多线程 1 线程.进程.多线程概述 2 创建线程 (重点) 2.1 继承Thread类(Thread类也实现了Runnable接口) 2.2 实现Runnable接口(无消息返回) 2. ...

多线程—生产者消费者模式、银行家算法

多线程—生产者消费者模式、银行家算法相关推荐

最新文章

热门文章