上一篇：经典案例：生产者-消费者模型 | 带你学《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的课程吗？从小白到大神，从入门到精通，更多精彩不容错过！免费为您提供更多的学习资源。
本内容视频来源于阿里云大学
