上一篇:经典案例:生产者-消费者模型 | 带你学《Java语言高级特性》之十一
【本节目标】
通过阅读本节内容,你将通过实操代码,进一步掌握synchronized关键字的使用方法,解决同步问题,学会使用Object类中提供的相关方法解决重复问题。
解决数据同步
如果要解决问题,首先解决的就是数据同步的处理问题,如果要想解决数据同步最简单的做法就是使用synchronized关键字定义同步代码块或同步方法,于是这个时候对于同步的处理就可以直接在Message类中完成。
范例:解决同步操作
class Message {
private String title;
private String content;
public synchronized void set(String title, String content) {
this.title = title;
try {
Thread.sleep(100); //模拟网络延迟
} catch (InterruptedException e) {
e.printStackTrace();
}
this.content = content;
}
public synchronized String get() {
try {
Thread.sleep(10); //模拟网络延迟
} catch (InterruptedException e) {
e.printStackTrace();
}
return this.title + " - " + this.content;
}
}
public class ThreadDemo {
public static void main(String[] args) throws Exception {
Message msg = new Message();
new Thread(new Producer(msg)).start(); //启动生产者线程
new Thread(new Consumer(msg)).start(); //启动消费者线程
}
}
class Producer implements Runnable {
private Message msg;
public Producer(Message msg) {
this.msg = msg;
}
@Override
public void run() {
for (int x = 0; x < 100; x++) {
if (x % 2 == 0) {
this.msg.set("王健", "宇宙大帅哥");
} else {
this.msg.set("小高", "猥琐第一人,常态保持");
}
}
}
}
class Consumer implements Runnable {
private Message msg;
public Consumer(Message msg) {
this.msg = msg;
}
@Override
public void run() {
for (int x = 0; x < 100; x++) {
System.out.println(this.msg.get());
}
}
}
图一 执行结果图
在进行同步处理的时候肯定需要有一个同步的处理对象,那么此时肯定要将同步操作交由Message处理是最合适的。这时数据已经可以正常保持一致了,但是对于重复操作的问题依然存在。
线程等待与唤醒
如果说现在要想解决生产者与消费者的问题,那么最好的解决方案就是使用等待与唤醒机制。而对于等待与唤醒的操作机制主要依靠是Object类中提供的方法处理的:
等待机制:
1、死等:
public final void wait() throws InterruptedException;
2、设置等待时间(毫秒):
public final void wait(long timeout) throws InterruptedException;
3、设置等待时间(纳秒):
public final void wait(long timeout, int nanos) throws InterruptedException;
唤醒第一个等待线程:public final void notify();
唤醒全部等待线程:public final void notifyAll();
如果此时有若干个等待线程的话,那么notify()表示的是唤醒第一个等待的,而其他的线程继续等待,而notifyAll()表示会唤醒所有等待的线程,哪个线程的优先级高就有可能先执行。
对于当前的问题主要的解决应该通过Message类完成处理。
范例:修改Message类
public class ThreadDemo {
public static void main(String[] args) throws Exception {
Message msg = new Message();
new Thread(new Producer(msg)).start(); //启动生产者线程
new Thread(new Consumer(msg)).start(); //启动消费者线程
}
}
class Producer implements Runnable {
private Message msg;
public Producer(Message msg) {
this.msg = msg;
}
@Override
public void run() {
for (int x = 0; x < 100; x++) {
if (x % 2 == 0) {
this.msg.set("王健", "宇宙大帅哥");
} else {
this.msg.set("小高", "猥琐第一人,常态保持");
}
}
}
}
class Consumer implements Runnable {
private Message msg;
public Consumer(Message msg) {
this.msg = msg;
}
@Override
public void run() {
for (int x = 0; x < 100; x++) {
System.out.println(this.msg.get());
}
}
}
class Message {
private String title;
private String content;
private boolean flag = true; //表示生产或消费的形式
//flag = true:允许生产,但不允许消费
//flag = false:允许消费,但不允许生产
public synchronized void set(String title, String content) {
if(this.flag==false){ //无法进行生产,应该等待被消费
try {
super.wait();
}catch (Exception e){
e.printStackTrace();
}
}
this.title = title;
try {
Thread.sleep(100); //模拟网络延迟
} catch (InterruptedException e) {
e.printStackTrace();
}
this.content = content;
this.flag=false; //已经生产过了
super.notify(); //唤醒等待的线程
}
public synchronized String get() {
if(this.flag==true){ //还未生产,需要等待
try {
super.wait();
}catch (Exception e){
e.printStackTrace();
}
}
try {
Thread.sleep(10); //模拟网络延迟
} catch (InterruptedException e) {
e.printStackTrace();
}
try {
return this.title + " - " + this.content;
}finally { //不管如何都要执行
this.flag=true; //继续生产
super.notify(); //唤醒等待的线程
}
}
}
图二 线程的等待与唤醒
这种处理形式就是在进行多线程开发过程之中最原始的处理方案,整个的等待、同步、唤醒机制都由开发者自行通过原生代码实现控制。
想学习更多的Java的课程吗?从小白到大神,从入门到精通,更多精彩不容错过!免费为您提供更多的学习资源。
本内容视频来源于阿里云大学