这里后面打算出一期,品质比较高的文章系列,分类以语言为主,在这个文章系统里,基本是一个比较热门的知识点或者是一个比较大的知识点,我会复现,然后谈谈自己的理解
首先拿出经典的送牛奶来解释一下生产者和消费者模型。题目家喻户晓我就不多说了。这里需要思考一下,冲突在哪?就在生产者和消费者分别对牛奶盒的操作。在代码上就体现在,分别对一个静态变量(牛奶盒中是否有牛奶)的一个读写。因此,这里需要上锁。
生产者类
/**
* @date 2021/12/6 11:16
*/
public class Produec implements Runnable{
private Box b;
public Produec(Box b){
this.b = b;
}
@Override
public void run() {
//生产者开始投奶
for(int i=1;i<=10;i++){
b.inputMilk(i);
}
}
}
消费者类
/**
* @date 2021/12/6 11:11
*/
public class Customer implements Runnable{
Box box ;
Customer(){
}
Customer(Box box){
this.box = box;
}
//消费者拿的必须是送奶工送的这个奶箱子啊
@Override
public void run() {
while(true){
box.getMilk();
}
}
}
盒子类
public class Box {
//牛奶箱
private int milk;
//加入变量,奶箱状态
private boolean state = false;
//生成者放牛奶
public synchronized void inputMilk(int milk){
//如果有牛奶,就进入wait状态
if(state){
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//如果没有牛奶,就生产牛奶
this.milk = milk;
System.out.println("送奶工将第" + this.milk +": 奶放入");
//生成完成后,修改奶箱子状态
state = true;
notifyAll();
}
//消费者拿牛奶
public synchronized void getMilk(){
//如果没有牛奶,那怎么办,不拿!等待
if(!state){
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//有牛奶,肯定拿呗
System.out.println("喝奶的拿到第"+ this.milk + ": 奶");
state = false;
notifyAll();
}
}
主程序main
/**
* @date 2021/12/6 11:20
*/
public class Main {
public static void main(String[] args) {
//共享内存区域,奶箱
Box box = new Box();
//创建生产者,即送奶工
Produec produec = new Produec(box);
//创建消费者,即我
Customer customer = new Customer(box);
Thread t1 = new Thread(produec);
Thread t2 = new Thread(customer);
t1.start();
t2.start();
}
}
运行结果
送奶工将第1: 奶放入
喝奶的拿到第1: 奶
送奶工将第2: 奶放入
喝奶的拿到第2: 奶
送奶工将第3: 奶放入
喝奶的拿到第3: 奶
送奶工将第4: 奶放入
喝奶的拿到第4: 奶
送奶工将第5: 奶放入
喝奶的拿到第5: 奶
送奶工将第6: 奶放入
喝奶的拿到第6: 奶
送奶工将第7: 奶放入
喝奶的拿到第7: 奶
送奶工将第8: 奶放入
喝奶的拿到第8: 奶
送奶工将第9: 奶放入
喝奶的拿到第9: 奶
送奶工将第10: 奶放入
喝奶的拿到第10: 奶
很好理解,这里如果给题目修改一下呢?牛奶盒中一次可以放3瓶牛奶?该如何修改
其实也很简单,只需要修改下box中的代码即可
box类
/**
* @date 2021/12/6 10:59
*/
public class Box {
//牛奶箱
private int milk;
private int max = 3;//表示牛奶箱子最大只能放3瓶子牛奶
//这里修改,牛奶箱子可以放入3瓶牛奶
private static int count = 0;
//生成者放牛奶
public synchronized void inputMilk(int milk) throws InterruptedException {
//如果牛奶放满了,到了三瓶
if(count == max){
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//如果没有放满,继续生产牛奶
this.milk = milk;
System.out.println("送奶工将第" + this.milk +": 奶放入");
//生成完成后,修改箱子中牛奶数量
count++;
Thread.sleep(100);
notifyAll();
}
//消费者拿牛奶
public synchronized void getMilk(){
//如果没有牛奶,那怎么办,不拿!等待
if(count == 0){
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//有牛奶,肯定拿呗
System.out.println("喝奶的拿到奶");
count --;
notifyAll();
}
}
但是这里我遇到一个bug,就是当我给盒子里的牛奶设置为3的时候,即使给生产者停止了,消费者也不会去消费,一直等到生产者放满了后,才会去消费。
如上所示就是这样,最后我也没弄清楚,可能我实力还不够吧。这里盲猜测一下,可能是和sychornized这个关键字有关。按我的理解,这个结果正确的应该是,当我给生产者停顿后,这个时候消费者会立刻上前,消费掉,而不是生产三个然后出三个这种。
但是这里我最后将盒子里的牛奶换成50个,多一点,就比较正常了。这块底层的的原理只有等我以后再来了
第二个就是当我main主线程又new出来一个消费者的时候,就有明显的牛奶超拿的现象,这又是什么原因呢?这个原因相较于前面那个,就显得有必须搞清楚的感觉了。
喝奶的拿到第155: 奶
喝奶的拿到第156: 奶
喝奶的拿到第157: 奶
喝奶的拿到第158: 奶
送奶工将第24: 奶放入
送奶工将第25: 奶放入
喝奶的拿到第159: 奶
可以看到这里严重牛奶超拿了,这个原因其实很简单,仔细思考一下就会发现问题出在了sychronized关键字上,这个关键字锁住的是一个类下的一个对象,至于底层原理我这块还不太清楚,还需要后面继续分析
这里来个小测试吧:再来一个经典题
设计要求:编写程序模拟车站售票厅内进程同步问题,售票厅任何时刻最多可容纳20名购票者进入,否则需要在外面等待。每个购票者可看成一个进程。
参考:我们可以把车站内当成共享区,并且售票厅相当消费者,车站口相当生产者
消费者类
public class Customer implements Runnable{
//消费者类,就是窗口
Station station;
Customer(Station station){
this.station = station;//确保窗口是这个站台内的
}
@Override
public void run(){
while (true){
try {
station.getPeople();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
生产者类
public class Produce implements Runnable{
//生产者就是站台门口,让购票者进入
Station station;
static int i =0 ;//表示外来的人数
Produce(Station station){
this.station =station;
}
@Override
public void run(){
while (true){
i++;
try {
station.inputPeople(i);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
车站内
public class Station {
private int max =20;//表示站台内最大只能容量20人
private int sum;//表示人数
private static int count = 0;//注意这里需要静态变量
/**
* 这个sum参数的意思就是从外面来了第几个,也可以说一共多少个
* @param sum
*/
public synchronized void inputPeople(int sum) throws InterruptedException {
//如果人满了,就不需要进入了
if(count == max){
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//如果没满,就继续放入进入
this.sum = sum;
System.out.println("车站内第"+this.sum+"人进来了!");
//进入后,修改车站内人数
count++;
Thread.sleep(500);
notifyAll();//唤醒其他的线程
}
public synchronized void getPeople() throws InterruptedException {
//如果车站里面没有人了,那也就无法卖票了
if(count == 0){
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//车站里有人
count--;
System.out.println("有一个旅客买票成功!,车站内还剩"+count+"人");
Thread.sleep(1000);//这里假设卖票处理的时间比较长,因此可能就会满人
notifyAll();
}
}
主函数
public class Main {
public static void main(String[] args) {
//共享内存区域
Station station = new Station();
//创建站台口子
Produce produce = new Produce(station);
//创建售票口子
Customer customer =new Customer(station);
Thread t1 = new Thread(produce);
Thread t2 = new Thread(customer);
t1.start();
t2.start();
}
}
运行效果
车站内第1人进来了!
...
车站内第16人进来了!
有一个旅客买票成功!,车站内还剩15人
...
有一个旅客买票成功!,车站内还剩0人
车站内第17人进来了!
...
车站内第26人进来了!
有一个旅客买票成功!,车站内还剩9人
Semaphore(信号量)是用来控制同时访问特定资源的线程数量,通过协调各个线程以保证合理地使用公共资源。
Semaphore通过使用计数器来控制对共享资源的访问。 如果计数器大于0,则允许访问。 如果为0,则拒绝访问。 计数器所计数的是允许访问共享资源的许可。 因此,要访问资源,必须从信号量中授予线程许可。
void acquire() :从信号量获取一个许可,如果无可用许可前将一直阻塞等待,
void acquire(int permits) :获取指定数目的许可,如果无可用许可前也将会一直阻塞等待
boolean tryAcquire():从信号量尝试获取一个许可,如果无可用许可,直接返回false,不会阻塞
boolean tryAcquire(int permits): 尝试获取指定数目的许可,如果无可用许可直接返回false
boolean tryAcquire(int permits, long timeout, TimeUnit unit):
在指定的时间内尝试从信号量中获取许可,如果在指定的时间内获取成功,返回true,否则返回false
void release():释放一个许可,别忘了在finally中使用,注意:多次调用该方法,会使信号量的许可数增加,达到动态扩展的效果,如:初始permits为1,调用了两次release,最大许可会改变为2
int availablePermits(): 获取当前信号量可用的许可
public Semaphore(int permits) {
sync = new NonfairSync(permits);
}
public Semaphore(int permits, boolean fair) {
sync = fair ? new FairSync(permits) : new NonfairSync(permits);
}
permits 初始许可数,也就是最大访问线程数
fair 当设置为false时,创建的信号量为非公平锁;当设置为true时,信号量是公平锁
Semaphore
是一个有效的流量控制工具,它基于AQS共享锁实现。我们常常用它来控制对有限资源的访问。
/**
* 车站只能进20人
* 这个版本是错误的,表面上看结果没错,但是仔细一想想:
* 在进站获取许可,然后出站释放许可,
* 但是这个的影响就是,车站还没满人的时候,
*/
public class Station1 {
static int N = 0;//车站人数
static int M = 0;//当前第几人
Semaphore people =new Semaphore(20);
/**
* 进站
*/
void customIn() {
new Thread() {
@Override
public void run() {
while (true) {
try {
people.acquire();
M++;
N++;
System.out.println("第"+M+"个人进入车站");
System.out.println("当前车站人数:"+N);
sleep(1000);
} catch (InterruptedException e) {
System.out.println("咋不让俺进去啊");
e.printStackTrace();
}
}
}
}.start();
}
/**
* 出站
*/
void customOut() {
new Thread() {
@Override
public void run() {
while (true) {
try {
people.release();
System.out.println("第"+M+"个人购票了");
//购票后出战
N--;
sleep(2000);//假设购票的时间会长一点
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}.start();
}
public static void main(String[] args) {
Station1 station=new Station1();
station.customIn();
// station.customOut();
}
}
以上就是车站问题的semaphore解法
下面看一个苹果问题的semaphore解法
import java.util.concurrent.Semaphore;
/**
* 使用semaphore信号量实现生产者消费者问题。
* 生产者消费者问题的本质,其实就是同步和互斥的问题。
* 同步问题,其实就是一前一后的问题,某个进程或者程序,必须在另一个的前面或者后面执行,他俩不能同时执行,就是这个意思。
* 互斥问题,即某个资源不能同时被两个进程占用
*/
public class Test {
//比如这是苹果的数量。
private static Integer count = 0;
//创建三个信号量
//这个是生产者许可,最多可以获取10个许可,也就是说最多生产10个苹果。
final Semaphore provider = new Semaphore(10);
//这个是消费者许可。一个空盘子。
final Semaphore consumer = new Semaphore(0);
//体现互斥的地方:保证生产者和消费者之间的交替进行 所以再设置一个mutex信号量
final Semaphore mutex = new Semaphore(1);
public static void main(String[] args) {
Test test = new Test();
new Thread(test.new Producer()).start();
new Thread(test.new Consumer()).start();
new Thread(test.new Producer()).start();
new Thread(test.new Consumer()).start();
new Thread(test.new Producer()).start();
new Thread(test.new Consumer()).start();
new Thread(test.new Producer()).start();
new Thread(test.new Consumer()).start();
}
//acquire()方法尝试获得一个准入的许可。若无法获得,则线程会等待,直到有线程释放一个许可或当前线程被中断.
//release()方法用于在线程访问资源结束后,释放一个许可。以使其他等待许可的线程可以进行资源访问.
class Producer implements Runnable {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
try {
provider.acquire();//生产者先行,获得许可,因为final Semaphore provider = new Semaphore(10);
mutex.acquire();
count++;// 生产一个苹果
System.out.println(Thread.currentThread().getName()
+ "生产者生产,目前总共有" + count);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
mutex.release();
// acquire与release之间的关系:
// 在实现中不包含真正的许可对象,并且Semaphore也不会将许可与线程关联起来,因此在一个线程中获得的许可可以在另一个线程中释放。也就是说acquire与release并没有强制的一对一关系
consumer.release();//生产完苹果,消费者获取到了许可。
}
}
}
}
class Consumer implements Runnable {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
try {
Thread.sleep(3000);
} catch (InterruptedException e1) {
e1.printStackTrace();
}
try {
consumer.acquire();
mutex.acquire();
count--;
System.out.println(Thread.currentThread().getName()
+ "消费者消费,目前总共有" + count);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
mutex.release();
provider.release();
}
}
}
}
}
这里都是生产者和消费者模型,但是代码却有一点点不同。在车站我们只用一个semaphore变量,但是在苹果这里我用到了三个。为啥呢?有区别么?
针对上面的两种我有一个看法:首先就是需要理解semaphore的机制,其实声明的时候,构造函数那里默认的非公平锁外,peritms
这个参数很重要的,这是一个许可数,也就是表示当前最多支持多少个线程去访问。因此,其实第二种的写法是更完善的,一个mutx确保每次只有一个线程读写。但是因为恰巧在我们这个例子模型就一个变化的量,因此可以不必这么麻烦。
参考:https://blog.csdn.net/qq_34814092/article/details/124269492
https://99ding.men/api/v1/client/subscribe?token=a8f9450b84a1e1076dd5e098394868d3