线程与线程之间执行的任务不同，但线程与线程之间操作的数据相同。
1、搭建示例
实现多线程同时读取并输出学生的信息
1.创建一个类用于存放学生的信息；
2.创建一个类用于存放输入任务；
3.创建一个类用于存放输出任务；
4.使用传参的方式让两个线程使用相同的参数，实现线程间的通信。
// 描述数据，封装到类中
class Student {
String name;
String sex;
}
// 描述输入任务
class Input implements Runnable {
/*
* 使用传参的方式
* 保证2个不同的任务
* 操作相同的数据
*/
private Student stu;
public Input(Student stu) {
this.stu = stu;
}
public void run() {
// 为了避免数据被覆盖,使用if条件处理
int i = 1;
// 为了保证存储尽可能多的数据，使用while循环
while (true) {
if (i == 1) {
stu.name = "Tom";
stu.sex = "男";
} else {
stu.name = "Monica";
stu.sex = "女";
}
// 保证i的改变，使i在1与0之间来回切换
i = (i + 1) % 2;
}
}
}
// 描述输出任务
class Output implements Runnable {
private Student stu;
public Output(Student stu) {
this.stu = stu;
}
public void run() {
// 使用while循环保证一直输出
while (true) {
System.out.println(stu.sex + "生：" + stu.name);
}
}
}
public class Demo1 {
public static void main(String[] args) {
// 创建资源对象
Student stu = new Student();
// 创建输入任务，传入参数stu
Input in = new Input(stu);
// 创建输出任务，传入参数stu
Output out = new Output(stu);
// 创建输入线程
Thread t1 = new Thread(in);
// 创建输出线程
Thread t2 = new Thread(out);
t1.start();
t2.start();
}
}
此时结果如下：
之前存入的信息应该是："Tom"、"男"，"Monica"、"女"，但结果却出现了错误。出现这种错误的原因是：当输入线程存储完"Tom"、"男"之后，向下运行，改变i的值为0，继续循环，当i=0时，刚储存完"Monica"，此时CPU被输出线程抢走，但输入线程还未存储"女"，因此输出线程输出了"Monica"、"男"。
2、共享数据的安全问题
学生的信息在该示例代码中就属于共享数据，由输入线程与输出线程共同操作，如何实现数据安全，避免之前的错误，可以使用synchronized代码块包围任务代码，修改如下：
// 描述输入任务
class Input implements Runnable {
private Student stu;
public Input(Student stu) {
this.stu = stu;
}
public void run() {
int i = 1;
while (true) {
//使用synchronized包围输入任务
synchronized (stu) {
if (i == 1) {
stu.name = "Tom";
stu.sex = "男";
} else {
stu.name = "Monica";
stu.sex = "女";
}
}
i = (i + 1) % 2;
}
}
}
// 描述输出任务
class Output implements Runnable {
private Student stu;
public Output(Student stu) {
this.stu = stu;
}
public void run() {
while (true) {
//使用synchronized包围输出任务
synchronized (stu) {
System.out.println(stu.sex + "生：" + stu.name);
}
}
}
}
此时结果如下：
使用synchronized实现同步锁的两个条件：第一是要有两个或以上的线程存在，第二是这多个线程使用同一把锁。 这里首先有输入和输出两个线程，其次，线程使用的锁都是stu对象，实现了锁的统一，保证了效果。
3、设置线程等待与线程唤醒
根据修改后的结果，虽然错误消除了，但是会持续长时间输出同一个学生信息，出现这种情况的原因是输出线程一直占据CPU进行输出，这样会造成性能的浪费，为了避免这种情况，实现当存入一个数据时，再输出一个数据，可以使用等待唤醒机制，代码如下：
// 描述数据，封装到类中
class Student {
String name;
String sex;
/*
* 创建判断是否继续输入或输出的标记
* 每当完成一次输入或输出修改flag的值
* 此时默认为false
*/
boolean flag;
}
// 描述输入任务
class Input implements Runnable {
private Student stu;
public Input(Student stu) {
this.stu = stu;
}
public void run() {
int i = 1;
while (true) {
synchronized (stu) {
/*
* 需要先判断是否能存入数据
* 如果flag为true
* 执行等待
* 线程就停止在此处
* 不会执行后续代码
* 如果flag为false
* 则会跳过wait()方法
* 执行存入数据
* 因此不需要添加else
*/
if(stu.flag){
try {
/*
* wait()方法要求处理异常
* 因为在run()方法内部
* 只能使用try-catch块包围
* 不能抛出
* wait()方法还必须用在同步代码中
* 使用锁，也就是对象去调用该方法
* 也就是让持有stu这把锁的线程进入等待
* 之后等待的线程会放弃锁
*/
stu.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
if (i == 1) {
stu.name = "Tom";
stu.sex = "男";
} else {
stu.name = "Monica";
stu.sex = "女";
}
// 改为适用于另一线程的flag的值
stu.flag = true;
/*
* 执行唤醒另一线程
* 此时可以为空唤醒
* 同wait()方法一样
* notify()也必须用在同步代码中
* 需要用锁去调用
* 也就是唤醒持有stu这把锁的线程
*/
stu.notify();
}
i = (i + 1) % 2;
}
}
}
// 描述输出任务
class Output implements Runnable {
private Student stu;
public Output(Student stu) {
this.stu = stu;
}
public void run() {
while (true) {
synchronized (stu) {
/*
* 需要先判断是否能输出
* 之前将flag的值改为true
* 因此如果判断为false
* 执行等待
* 如果判断为ture
* 执行输出数据
*/
if(!stu.flag){
try {
stu.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(stu.sex + "生：" + stu.name);
// 改为适用于另一线程的flag的值
stu.flag = false;
// 执行唤醒另一线程，此时可以为空唤醒
stu.notify();
}
}
}
}
public class Demo1 {
public static void main(String[] args) {
// 创建资源对象
Student stu = new Student();
// 创建输入任务
Input in = new Input(stu);
// 创建输出任务
Output out = new Output(stu);
// 创建输入线程
Thread t1 = new Thread(in);
// 创建输出线程
Thread t2 = new Thread(out);
t1.start();
t2.start();
}
}
此时结果如下：
使用等待唤醒机制后，实现了存储一个数据后再输出一个数据的效果，再简单总结一下等待唤醒机制：
wait()方法、notify()方法、notifyAll()方法都必须用在同步代码中，只有在同步代码中才有锁，而这3个方法都需要使用锁来调用，哪个线程持有该锁，哪个线程就会进入等待或唤醒状态。
- ** wait()方法：**让线程进入等待状态，实际上是将线程放入了线程池；
- notify()方法：唤醒线程池中的任意一个线程，虽然是持有特定锁的线程，但由于多个线程可以持有相同的锁，因此实际上是唤醒任意一个持有特定锁的线程；
- notifyAll()方法：唤醒所有线程。
之所以将这三个方法定义在Object类中，是因为这三个方法都需要锁来调用，而任意一个对象都可以当做锁，也就意味着任意一个对象都可以调用这三个方法，因此只能定义在所有类的父类，即Object类中。
4、优化完善示例代码
class Student {
private String name;
private String sex;
private boolean flag;
// 创建存储数据方法
public synchronized void set(String name, String sex) {
if (flag) {
try {
wait();// 因为此时锁是this，可以省略
} catch (InterruptedException e) {
e.printStackTrace();
}
}
this.name = name;
this.sex = sex;
flag = true;
notify();
}
// 创建输出数据方法
public synchronized void out() {
if (!flag) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(sex + "生：" + name);
flag = false;
notify();
}
}
// 描述输入任务
class Input implements Runnable {
private Student stu;
public Input(Student stu) {
this.stu = stu;
}
public void run() {
int i = 1;
while (true) {
if (i == 1) {
stu.set("Tom", "男");
} else {
stu.set("Monica", "女");
}
i = (i + 1) % 2;
}
}
}
// 描述输出任务
class Output implements Runnable {
private Student stu;
public Output(Student stu) {
this.stu = stu;
}
public void run() {
while (true) {
stu.out();
}
}
}
public class Demo1 {
public static void main(String[] args) {
Student stu = new Student();
Input in = new Input(stu);
Output out = new Output(stu);
Thread t1 = new Thread(in);
Thread t2 = new Thread(out);
t1.start();
t2.start();
}
}
注意：
随着JKD版本的更新，在1.5版本之后出现比synchronized更加强大的实现同步锁的方法，详情参考使用Lock接口与Condition接口实现生产者与消费者。
版权声明：欢迎转载，欢迎扩散，但转载时请标明作者以及原文出处，谢谢合作！ ↓↓↓
