这里后面打算出一期，品质比较高的文章系列，分类以语言为主，在这个文章系统里，基本是一个比较热门的知识点或者是一个比较大的知识点，我会复现，然后谈谈自己的理解
经典题目
首先拿出经典的送牛奶来解释一下生产者和消费者模型。题目家喻户晓我就不多说了。这里需要思考一下，冲突在哪？就在生产者和消费者分别对牛奶盒的操作。在代码上就体现在，分别对一个静态变量（牛奶盒中是否有牛奶）的一个读写。因此，这里需要上锁。
生产者类
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
/** * @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); } } } |
消费者类
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
/** * @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(); } } } |
盒子类
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 |
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
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
/** * @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 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
送奶工将第1: 奶放入 喝奶的拿到第1: 奶 送奶工将第2: 奶放入 喝奶的拿到第2: 奶 送奶工将第3: 奶放入 喝奶的拿到第3: 奶 送奶工将第4: 奶放入 喝奶的拿到第4: 奶 送奶工将第5: 奶放入 喝奶的拿到第5: 奶 送奶工将第6: 奶放入 喝奶的拿到第6: 奶 送奶工将第7: 奶放入 喝奶的拿到第7: 奶 送奶工将第8: 奶放入 喝奶的拿到第8: 奶 送奶工将第9: 奶放入 喝奶的拿到第9: 奶 送奶工将第10: 奶放入 喝奶的拿到第10: 奶 |
很好理解，这里如果给题目修改一下呢？牛奶盒中一次可以放3瓶牛奶？该如何修改
其实也很简单，只需要修改下box中的代码即可
box类
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 |
/** * @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出来一个消费者的时候，就有明显的牛奶超拿的现象，这又是什么原因呢？这个原因相较于前面那个，就显得有必须搞清楚的感觉了。
|
1 2 3 4 5 6 7 |
喝奶的拿到第155: 奶 喝奶的拿到第156: 奶 喝奶的拿到第157: 奶 喝奶的拿到第158: 奶 送奶工将第24: 奶放入 送奶工将第25: 奶放入 喝奶的拿到第159: 奶 |
可以看到这里严重牛奶超拿了，这个原因其实很简单，仔细思考一下就会发现问题出在了sychronized关键字上，这个关键字锁住的是一个类下的一个对象，至于底层原理我这块还不太清楚，还需要后面继续分析
Test
这里来个小测试吧：再来一个经典题
设计要求：编写程序模拟车站售票厅内进程同步问题，售票厅任何时刻最多可容纳20名购票者进入，否则需要在外面等待。每个购票者可看成一个进程。
参考:我们可以把车站内当成共享区，并且售票厅相当消费者，车站口相当生产者
消费者类
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
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); } } } } |
生产者类
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
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); } } } } |
车站内
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 |
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(); } } |
主函数
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
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 2 3 4 5 6 7 8 9 10 |
车站内第1人进来了! ... 车站内第16人进来了! 有一个旅客买票成功!,车站内还剩15人 ... 有一个旅客买票成功!,车站内还剩0人 车站内第17人进来了! ... 车站内第26人进来了! 有一个旅客买票成功!,车站内还剩9人 |
Semaphore
定义
Semaphore（信号量）是用来控制同时访问特定资源的线程数量，通过协调各个线程以保证合理地使用公共资源。
Semaphore通过使用计数器来控制对共享资源的访问。 如果计数器大于0，则允许访问。 如果为0，则拒绝访问。 计数器所计数的是允许访问共享资源的许可。 因此，要访问资源，必须从信号量中授予线程许可。
主要方法
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
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()： 获取当前信号量可用的许可 |
Semaphore构造函数
|
1 2 3 4 5 6 7 8 9 10 |
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共享锁实现。我们常常用它来控制对有限资源的访问。
- 每次使用资源前，先申请一个信号量，如果资源数不够，就会阻塞等待；
- 每次释放资源后，就释放一个信号量。
应用
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 |
/** * 车站只能进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解法
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 |
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中的思考
针对上面的两种我有一个看法：首先就是需要理解semaphore的机制，其实声明的时候，构造函数那里默认的非公平锁外，peritms这个参数很重要的，这是一个许可数，也就是表示当前最多支持多少个线程去访问。因此，其实第二种的写法是更完善的，一个mutx确保每次只有一个线程读写。但是因为恰巧在我们这个例子模型就一个变化的量，因此可以不必这么麻烦。
四种方式实现消费者-生产者模型
参考：https://blog.csdn.net/qq_34814092/article/details/124269492
https://99ding.men/api/v1/client/subscribe?token=a8f9450b84a1e1076dd5e098394868d3
