整理面试题---线程的生产者和消费者实现
最近整理面试题目又有消费者生产者的问题，某人教的早就溜掉了，正好整理知识点（有错欢迎指正）
水滴筹面试题
采用Java多线程技术（例如wait和notify），设计实现一个符合生产者和消费者的程序，对一个对象（枪膛）进行操作，其最大容量是20颗子弹，生产者线程是一个压入线程，它不断向枪膛中压入子弹；消费者线程是一个射出线程，它不断从枪膛中射出子弹。
实体类：
package cn.HYQ.hyq.TextQTScond;
import java.util.ArrayList;
import java.util.List;
public class TextQTScond {
static class MyStack {
//共享子弹对象
private int bullet = 0;
// 生产
@SuppressWarnings("unchecked")
public synchronized void pressIn() {
try {
while (bullet == 20) { // 多个生产者
System.out.println("枪膛子弹已经满了，线程 "
+ Thread.currentThread().getName() + " 进入等待状态");
this.wait();
}
while(bullet < 20){
//根据容量压入子弹
bullet++;
}
System.out.println("线程 " + Thread.currentThread().getName()
+ " 已经压满子弹，该枪膛已满已满，可以唤醒消费线程");
this.notifyAll(); // 全部唤醒
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 消费
public synchronized String ejection() {
String returnValue = "";
try {
while (bullet == 0 ) { // 多个消费者
System.out.println("枪膛已空，线程 "
+ Thread.currentThread().getName() + " 进入等待状态");
this.wait();
}
while(bullet < 1){
//把子弹消费完
bullet--;
}
System.out.println("线程 " + Thread.currentThread().getName()
+ " 子弹经过消费，枪膛已空");
this.notifyAll(); // 一样需要全部唤醒
} catch (InterruptedException e) {
e.printStackTrace();
}
return returnValue;
}
}
//生产者
static class P_Thread extends Thread {
private MyStack myStack;
public P_Thread(MyStack myStack,String name) {
super(name);
this.myStack = myStack;
}
public void pushService() {
myStack.pressIn();
}
@Override
public void run() {
while (true) {
myStack.pressIn();
}
}
}
//消费者
static class C_Thread extends Thread {
private MyStack myStack;
public C_Thread(MyStack myStack,String name) {
//别名
super(name);
this.myStack = myStack;
}
@Override
public void run() {
while (true) {
myStack.ejection();
}
}
}
//测试类
public static class Run {
public static void main(String[] args) throws InterruptedException {
MyStack myStack = new MyStack();
P_Thread pThread1 = new P_Thread(myStack, "P1");
P_Thread pThread2 = new P_Thread(myStack, "P2");
P_Thread pThread3 = new P_Thread(myStack, "P3");
pThread1.start();
pThread2.start();
pThread3.start();
C_Thread cThread1 = new C_Thread(myStack, "C1");
C_Thread cThread2 = new C_Thread(myStack, "C2");
C_Thread cThread3 = new C_Thread(myStack, "C3");
cThread1.start();
cThread2.start();
cThread3.start();
}
}
}
结果：
搞定
线程生产消费协作
基本实现，实体类：
public class Express {
public final static String CITY = "SQ";
private int km;//快递运输里程数
private int uesd;
private String site;//快递到达地
private String usedsite;
public Express() {
}
public Express(int km, String site) {
this.km = km;
this.site = site;
}
//变化公里数，然后通知处于wait状态并需要处理公里数的线程进行业务处理
public synchronized void changeKm(){
this.uesd = this.km;
this.km = 200;
//在对象上等待和唤醒，因为一个对象有多个条件，
//notify()是唤醒单个线程
//但是就要锁对象里面的对应的变量对象,否则会出现唤醒错误的条件
// 要是对notifyAll，就会唤醒对象所有的条件，可能会造成唤醒了不需要的条件
notifyAll();
}
//变化地点，然后通知处于wait状态并需要处理地点的线程进行业务处理
public synchronized void changeSite(){
//当地点发生变化的时候进行通知一下
this.usedsite = this.site;
this.site = "GZ";
notifyAll();
}
//线程等待公里的变化
public synchronized void waitKm(){
while(this.km<100){
//所有jdk式实现阻塞状态都要对终端进行处理
try {
//调用Object的方法
this.wait();
System.out.println("Thread["+Thread.currentThread().getId()
+"] 被 notify 了");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("used to be "+this.uesd+" now change to "+this.km);
}
//线程等待目的地的变化
public synchronized void waitSite(){
while(this.site.equals(CITY)){//快递到达目的地
try {
wait();
System.out.println("thread["+Thread.currentThread().getId()
+"]被 notify 了");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("原本地址是 "+this.usedsite+",现在是 "+this.site+",返回给用户");
}
}
测试类：
//测试类
public class TestWN {
//创建静态对象
private static Express hyq = new Express(0,Express.CITY);
//检查里程数变化的线程,调用wait,不满足条件，线程一直等待
private static class CheckKm extends Thread{
@Override
public void run() {
hyq.waitKm();
}
}
//检查地点变化的线程
private static class CheckSite extends Thread{
@Override
public void run() {
hyq.waitSite();
}
}
public static void main(String[] args) throws InterruptedException {
//各自创建三个线程
for(int i=0;i<3;i++){
new CheckSite().start();
}
for(int i=0;i<3;i++){
new CheckKm().start();
}
Thread.sleep(1000);
hyq.changeKm();//改变公里数
//hyq.changeSite();
}
}
跑起来看看：
总结用发：
最基本是两个线程之间的合作，线程 A 修改了某对象的值，并通知另一个线程，另一个线程 B 接收到了变化，B 进行相应的操作，开始于一个线程， 最终执行在另一个线程。
A为生产者，B为消费者，实现做什么到怎么做的过程，消费者持续 while 判断变量的条件，条件满足则退出 while 循环，完成类中的剩下操作。
缺点：
- 低及时性。
- 消耗大，线程中我开了睡眠时间，但是很明显发现时间越长唤醒的效果越好，但是消耗内存和资源处理器也会更大，导致程序的无端的消耗。
等待/通知机制
是指一个线程 A 调用了对象 O 的 wait()方法进入等待状态，而另一个线程 B 调用了对象O 的notify()或者notifyAll()方法，线程 A 收到通知后从对象O 的wait() 方法返回，进而执行后续操作。上述两个线程通过对象 O 来完成交互，而对象上的 wait()和 notify/notifyAll()的关系就如同开关信号一样，用来完成等待方和通知方之间的交互工作。
这几个方法不是thread的方法，是object的方法，因为是在某个对象上的等待和通知
—notify()：
通知一个在对象上等待的线程,使其从wait 方法返回,而返回的前提是该线程获取到了对象的锁，没有获得锁的线程重新进入 WAITING 状态。
—notifyAll()：
通知所有等待在该对象上的线程
—wait()
调用该方法的线程进入 WAITING 状态,只有等待另外线程的通知或被中断才会返回.需要注意,调用 wait()方法后,会释放对象的锁
—wait(long)
超时等待一段时间,这里的参数时间是毫秒,也就是等待长达n 毫秒,如果没有通知就超时返回
—wait (long,int)
对于超时时间更细粒度的控制，单位向下兼容到纳秒
等待和通知的标准范式
等待方遵循如下原则。
- 获取对象的锁。
- 如果条件不满足，那么调用对象的 wait()方法，被通知后仍要检查条件。
- 条件满足则执行对应的逻辑。
通知方遵循如下原则。
synchronized(公用对象或者搞个一私有的){
while(条件不满足){
对象.wait();
}
对象处理逻辑（或者打包放另一个类中）
}
1）获得对象的锁。
2）改变条件。
3）通知所有等待在对象上的线程。
syhcnronized(公用对象或者搞个一私有的){
改变条件
//notify放最后，还有要All(最好)
对象.notifyAll();
}
在调用 wait（）、notify()系列方法之前，线程必须要获得该对象的对象级别锁，即只能在同步方法或同步块中调用 wait（）方法、notify()系列方法
进入 wait（）方法后，当前线程释放锁，在从 wait（）返回前，线程与其他线程竞争重新获得锁，
执行notify()系列方法的线程退出调用了notifyAll 的synchronized 代码块的时候后，线程之间会发生竞争。
如果其中一个线程获得了该对象锁，该线程则继续往下执行，它退出 synchronized 代码块，释放锁后，其他的已经被唤醒的线程将会继续竞争获取该锁，一直进行下去，直到所有被唤醒的线程都执行完毕。
notify 和 notifyAll
尽可能用 notifyall()，少用 notify()，因为 notify()是唤醒单个线程，因此无法保证被唤醒的这个线程一定是需要唤醒的线程，就要锁对象里面的对应的变量对象,否则会出现唤醒错误的条件，要是对notifyAll，就会唤醒对象所有的条件，但可能会造成唤醒了不需要的条件
——睡觉
278
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
