前言:
我们都听说过生产者和消费者的例子吧,现在来模拟一下。生产者生产面包,消费者消费面包。假定生产者将生成出来的面包放入篮子中,消费者从篮子中取。这样,当篮子中没有面包时,消费者不能取。当篮子满了以后,消费者不能一直生产。
思考:
使用面向对象的思想进行分析,涉及的事物有:生产者、消费者、篮子和面包。两个线程有:生产者的生产行为、消费者的消费行为。
Bread面包类
class Bread{
int id;
Bread(int id){
this.id=id;
}
public String toString(){
return "Bread:"+id;
}
}
SyncStack篮子类
在篮子中,一般先放入的面包最后才取出,因此这里可以模拟数据结构栈的操作,提供了两个方法push()和pop()。
这里,假定篮子的最大容量为6个面包。
class SyncStack{
int index=0;
Bread[] arrWT=new Bread[6];
//1、放入
public synchronized void push(Bread wt){
//装满了
//if(index==arrWT.length){ 防止发生异常之后,篮子满了仍然生成出现问题
while(index==arrWT.length){
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//叫醒wait中的线程
this.notify();
//this.notifyAll(); //叫醒所有
arrWT[index]=wt;
index++;
}
//2、拿出
public synchronized Bread pop(){
//篮子空了
while(index==0){
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
this.notify();
index--;
return arrWT[index];
};
}
生产者和消费者
终于轮到线程类出场了!生产者Producer实现如下,消费者Consumer类也十分类似,只是不再具备生产面包的功能,并且将push方法换成了pop,在这里就不展示了。
class Producer implements Runnable{
//持有框的引用
SyncStack ss=null;
Producer(SyncStack ss){
this.ss=ss;
}
@Override
public void run() {
for (int i = 1; i < 20; i++) {
Bread wt=new Bread(i);
//扔到框里
ss.push(wt);
System.out.println("producer:"+wt);
try {
Thread.sleep((long) (Math.random()*1000));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
这里我们简单的测试一下,一个生产者和一个消费者。
public static void main(String[] args) {
SyncStack ss=new SyncStack();
Producer p=new Producer(ss);
Consumer c=new Consumer(ss);
new Thread(p).start();
new Thread(c).start();
}
基本符合前面的要求
分析:
1、synchronized
一种同步锁,可以修饰代码块、方法等。当一个线程访问其修饰的内容时,视图访问该对象的线程将被阻塞。举个小例子:
/**
* 获得当前时间
*/
public synchronized static void getTime() {
System.out.println("1、进入获取时间方法=====");
Date date = new Date();
DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String time = format.format(date);
System.out.println("2、"+Thread.currentThread().getName() + ":" + time);
System.out.println("3、获取时间成功=====");
System.out.println();
}
我们启100次线程去调用他,在没有加synchronized关键字时,截取部分打印结果如下图:
加上关键字之后,打印结果如下:
可以很容易看出,在该方法前加上synchronized关键字之后,其他线程如果想继续访问,就会被阻塞,等待该线程执行结束后,其他线程才可以继续访问。
在上面消费者和生成者的例子中,我们在SyncStack的push和pop方法前都加上了synchronized关键字,就是为了保证“放”和“取”的原子性,这样模拟的结果才是合理的。
那么有人可能会问,生产者生产馒头和消费者消费馒头是否需要保持原子性,同一时间只允许一个线程执行呢?结合实际情况,可能有多个生产者、消费者同时进行操作,因此,这里不应做限制。
2、sleep()和wait()
在上面的例子中,Producer和Consumer内部使用的Thread.sleep()方法,而在SyncStack中的push和pop中却是用的wait()方法。这两个方法看似功能类似,有什么差别呢?
首先,翻到他们的根去看定义。注释看不懂可以先不看,不过注释就把他们的区别都说明白了。
wait()
public class Object {
/**
* Causes the current thread to wait until another thread invokes the
* {@link java.lang.Object#notify()} method or the
* {@link java.lang.Object#notifyAll()} method for this object.
* In other words, this method behaves exactly as if it simply
* performs the call {@code wait(0)}.
* <p>
* The current thread must own this object's monitor.
*/
public final void wait() throws InterruptedException {
<span style="white-space:pre"> wait(0);</span>
}
}
sleep()
public
class Thread implements Runnable {
/**
* Causes the currently executing thread to sleep (temporarily cease
* execution) for the specified number of milliseconds, subject to
* the precision and accuracy of system timers and schedulers. The thread
* does not lose ownership of any monitors.
*/
public static native void sleep(long millis) throws InterruptedException;
}
先说点肤浅的差别:
wait()是Object类中的方法,sleep()是Thread类中的。sleep必须指明挂起或睡眠的时间,而wait不需要。
上面注释中说的:
sleep()方法——占着CPU睡觉:CPU部分资源别占用,其他线程无法进入,但并不会失去他的监控,等到指定时间到了以后,继续恢复执行。
wait() 方法——等待使用CPU:线程会放弃对象锁,直到收到notify()通知才会进入准备状态。
我的理解:
在该实例中,push和pop中在“篮子空了”、“篮子装满了”的情况下使用了wait()方法。此时,已经无法继续工作下去,需要让出CPU给其他操作,才能保证生产-消费线进行。等到"篮子中有面包"情况时,调用notify通知线程执行。
Producer和Consumer中的sleep()方法是为了让放大彼此交替的差距,来接近现实生活的状态。