多线程
1.实现多线程
1.1 进程
进程：是正在运行的程序
- 是系统进行资源分配和调用的独立单位
- 每一个进程都有它自己的内存空间和系统资源
1.2 线程
线程：是进程中的单个顺序控制流，是一条执行路径
- 单线程：一个进程如果只有一条执行路径，则称为单线程程序
- 多线程：一个进程如果有多条执行路径，则称为多线程程序
举例：记事本程序、扫雷程序
1.3 多线程的实现方式
方式1：继承Thread类
- 定义一个类MyThread继承Thread类
- 在MyThread类中重写run()方法
- 创建MyThread类的对象
- 启动线程
两个小问题：
-
为什么要重写run()方法？
因为run()是用来封装被线程执行的代码
-
run()和start()的区别？
run()：封装线程执行的代码，直接调用，相当于普通方法的调用
start()：启动线程；然后由JVM调用次线程的run()方法
package com.advanced.thread;
public class MyThreadDemo01 {
public static void main(String[] args) {
MyThread my1 = new MyThread();
MyThread my2 = new MyThread();
// my1.run();//调用普通run()方法，未启动线程
// my2.run();
//void start(): 导致此线程开始执行; Java虚拟机调用此线程的run方法
my1.start();
my2.start();
}
}
class MyThread extends Thread{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(i);
}
}
}
1.4 设置和获取线程名称
Thread类中设置和获取线程名称的方法
- void setName(String name)：将此线程的名称更改为等于参数 name
- String getName()：返回此线程的名称
- 通过构造方法也可以设置线程名称
如何获取main()方法所在的线程名称？
- public static Thread currentThread()：返回对当前正在执行的线程对象的引用
package com.advanced.thread;
public class MyThreadDemo02 {
public static void main(String[] args) {
// MyThread1 my1 = new MyThread1();
// MyThread1 my2 = new MyThread1();
//
// //void setName(String name)：将此线程的名称更改为等于参数 name
// my1.setName("高铁");
// my2.setName("飞机");
//Thread(String name):分配一个新的 Thread对象
// MyThread1 my1 = new MyThread1("高铁");
// MyThread1 my2 = new MyThread1("飞机");
// my1.start();//高铁:0...飞机:0...
// my2.start();
//static Thread currentThread()：返回对当前正在执行的线程对象的引用
System.out.println(Thread.currentThread().getName());//main
}
}
class MyThread1 extends Thread{
public MyThread1() {
}
public MyThread1(String name) {
super(name);
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
//String getName()：返回此线程的名称
System.out.println(getName()+":"+i);//Thread-0:0...Thread-1:0...
}
}
}
/* 源码分析：
private String name;
public Thread() {
init(null, null, "Thread-" + nextThreadNum(), 0);
}
public Thread(String name) {
init(null, null, name, 0);
}
private static int threadInitNumber;//0
private static synchronized int nextThreadNum() {
return threadInitNumber++;//
}
private void init(ThreadGroup g, Runnable target, String name,
long stackSize) {
init(g, target, name, stackSize, null, true);
}
private void init(ThreadGroup g, Runnable target, String name,
long stackSize, AccessControlContext acc,
boolean inheritThreadLocals) {
this.name = name;
}
public final String getName() {
return name;
}
public final void setName(String name) {
this.name = name;
}
*/
1.5 线程调度
线程有两种调度模型
- 分时调度模型：所有线程轮流使用CPU的使用权，平均分配每个线程使用CPU的时间片
- 抢占式调度模型：优先让优先级高的线程使用CPU,如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的CPU时间片相对多一些
Java使用的是抢占式调度模型
假如计算机只有一个CPU，那么CPU在某一时刻只能执行一条指令，线程只有得到CPU时间片，也就是使用权，才可以执行指令。所以说多线程程序的执行是有随机性的，因为谁抢到CPU的使用权是不一定的
Thread类中设置和获取线程优先级的方法
-
public final int getPriority()：返回此线程的优先级
-
public final void setPriority(int newPriority)：更改此线程的优先级
线程默认优先级是5，线程优先级范围是：1-10
线程优先级高仅仅表示线程获取CPU时间片的几率高，但是要在次数比较多，或者多次运行才能看到想要的效果
package com.advanced.thread;
public class ThreadPriorityDemo {
public static void main(String[] args) {
ThreadPriority tp1 = new ThreadPriority();
ThreadPriority tp2 = new ThreadPriority();
ThreadPriority tp3 = new ThreadPriority();
//public final int getPriority()：返回此线程的优先级
// System.out.println(tp1.getPriority());//5
// System.out.println(tp2.getPriority());//5
// System.out.println(tp3.getPriority());//5
tp1.setName("飞机");
tp2.setName("高铁");
tp3.setName("汽车");
//public final void setPriority(int newPriority)：更改此线程的优先级
// tp1.setPriority(100);//IllegalArgumentException
// System.out.println(Thread.MAX_PRIORITY);//10
// System.out.println(Thread.MIN_PRIORITY);//1
// System.out.println(Thread.NORM_PRIORITY);//5
tp1.setPriority(10);
tp2.setPriority(5);
tp3.setPriority(1);
tp1.start();
tp2.start();
tp3.start();
}
}
class ThreadPriority extends Thread{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(getName()+":"+i);
}
}
}
1.6 线程控制
| 方法名 | 说明 |
|---|---|
| static void sleep(long millis) | 使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行），具体取决于系统定时器和调度程序的精度和准确性 |
| void join() | 等待这个线程死亡 |
| void setDaemon(boolean on) | 将此线程标记为 daemon线程或用户线程，当运行的唯一线程都是守护进程线程时，Java虚拟机将退出 |
package com.advanced.thread;
public class ControlThreadDemo {
public static void main(String[] args) {
//sleep()方法暂停线程
// sleepDemo();
//join()方法等待线程死亡
// joinDemo();
//void setDaemon(boolean on)将此线程标记为daemon线程或用户线程，当运行的唯一线程都是守护进程线程时，Java虚拟机将退出
//设置主线程为刘备
Thread.currentThread().setName("刘备");
setDaemonDemo();
}
private static void setDaemonDemo() {
ControlThread s1 = new ControlThread();
ControlThread s2 = new ControlThread();
s1.setName("关羽");
s2.setName("张飞");
//设置守护线程
s1.setDaemon(true);
s2.setDaemon(true);
s1.start();
s2.start();
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
private static void joinDemo() {
ControlThread s1 = new ControlThread();
ControlThread s2 = new ControlThread();
ControlThread s3 = new ControlThread();
s1.setName("康熙");
s2.setName("四阿哥");
s3.setName("八阿哥");
s1.start();
try {
//void join():等待这个线程死亡
s1.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
s2.start();
s3.start();
}
private static void sleepDemo() {
ControlThread s1 = new ControlThread();
ControlThread s2 = new ControlThread();
ControlThread s3 = new ControlThread();
s1.setFlag(true);
s1.setName("曹操");
s2.setName("孙权");
s3.setName("刘备");
s1.start();
s2.start();
s3.start();
}
}
class ControlThread extends Thread{
public static boolean flag;
public void setFlag(boolean flag){
this.flag = flag;
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(getName()+":"+i);
if(flag) {
try {
//static void sleep(long millis):使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行)
sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
1.7 线程生命周期
在线程的生命周期中,它要经过新建(New)、就绪(Runnable)、运行(Running)、阻塞(Blocked)和死亡(Dead)五种状态。
新建(New)：通过new()方法创建线程对象
就绪(Runnable)：通过start()方法使线程进入就绪队列。此时线程具有执行资格，没有执行权
运行(Running)：当就绪队列中的线程抢到CPU的执行权，就进入运行队列。此时线程具有执行资格和执行权。若运行过程中，其他线程抢走CPU执行权，则该进程重新回到就绪队列
阻塞(Blocked)：当运行队列中线程调用sleep()或其他阻塞式方法时，将进入阻塞队列。此时线程没有执行资格和执行权。若线程sleep()时间到或阻塞方式结束时，线程重新回到就绪队列
死亡(Dead)：当run()方法结束，或调用stop()方法，或其他异常等导致程序终止，线程死亡，变成垃圾
1.8 多线程实现方式
方式2：实现Runnable接口
- 定义一个类MyRunnable实现Runnable接口
- 在MyRunnable类中重写run()方法
- 创建MyRunnable类的对象
- 创建Thread类的对象，把MyRunnable对象作为构造方法的参数
- 启动线程
多线程实现方式：
- 继承Thread类
- 实现Runnable接口
相比继承Thread类，实现Runnable接口的好处：
- 避免Java单继承的局限性
- 适合多个相同程序的代码去处理同一个资源的情况，把线程和程序的代码、数据有效分离，较好的体现了面向对象的思想
package com.advanced.thread;
public class MyRunnableDemo {
public static void main(String[] args) {
//创建MyRunnable对象
MyRunnable my = new MyRunnable();
//创建Thread类的对象，把MyRunnable对象作为构造方法的参数
// Thread(Runnable target):分配一个新的 Thread对象
// Thread t1 = new Thread(my);
// Thread t2 = new Thread(my);
//Thread(Runnable target, String name):分配一个新的 Thread对象,name - 新线程的名称
Thread t1 = new Thread(my,"高铁");
Thread t2 = new Thread(my,"飞机");
t1.start();
t2.start();
}
}
class MyRunnable implements Runnable{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
2.线程同步
2.1 案例：卖票
需求：某电影院正在上映国产大片，共有100张票，有3个窗口卖票，请设计程序实现电影院卖票
package com.advanced.thread;
public class SellTicketDemo {
public static void main(String[] args) {
SellTicket st = new SellTicket();
Thread t1 = new Thread(st, "窗口一");
Thread t2 = new Thread(st, "窗口二");
Thread t3 = new Thread(st, "窗口三");
t1.start();
t2.start();
t3.start();
}
}
class SellTicket implements Runnable{
private int tickets = 100;
@Override
public void run() {
while (true) {
if (tickets > 0) {
tickets--;
System.out.println(Thread.currentThread().getName() + "卖票一张，余票还有" + tickets + "张");
} else {
System.out.println("票已售完！！！");
break;
}
}
}
}
2.2 卖票案例思考
刚才讲解了卖票案例程序，好像没什么问题。但实际生活中，出票过程需要一点时间，所以，在出售一张票时，需要一点时间延迟，因此需要对程序进行优化。接下来我们去修改卖票程序中的卖票动作：每次出票时间100ms，用sleep()方法实现
package com.advanced.thread;
public class SellTicketDemo02 {
public static void main(String[] args) {
SellTicket02 st = new SellTicket02();
Thread t1 = new Thread(st, "窗口1");
Thread t2 = new Thread(st, "窗口2");
Thread t3 = new Thread(st, "窗口3");
t1.start();
t2.start();
t3.start();
}
}
class SellTicket02 implements Runnable {
private static int tickets = 100;
@Override
public void run() {
//相同的票出现了多次
// while(true){
// //tickets = 100;
// //t1,t2,t3
// //假设t1抢到CPU执行权
// if (tickets>0){
// try {
// //通过sleep()方法模拟出票时间
// Thread.sleep(100);
// //t1线程休息100毫秒
// //t2线程抢到CPU执行权，t2线程就开始执行，执行到这里时，t2休息100毫秒
// //t3线程抢到CPU执行权，t3线程就开始执行，执行到这里时，t3休息100毫秒
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
// //假设线程按顺序醒过来
// //t1线程抢到CPU执行权，在控制台输出：窗口1在出售第100张票
// System.out.println(Thread.currentThread().getName()+"在出售第"+tickets+"张票");
// //t2线程抢到CPU执行权，在控制台输出：窗口2在出售第100张票
// //t3线程抢到CPU执行权，在控制台输出：窗口3在出售第100张票
// tickets--;
// //如果这三个线程还是按顺序执行，这里就执行了3次tickets--的操作，最终票就变为97
// }
// }
//票出现了负数
while(true){
//tickets = 1;
//t1,t2,t3
//假设t1抢到CPU执行权
if (tickets>0){
try {
//通过sleep()方法模拟出票时间
Thread.sleep(100);
//t1线程休息100毫秒
//t2线程抢到CPU执行权，t2线程就开始执行，执行到这里时，t2休息100毫秒
//t3线程抢到CPU执行权，t3线程就开始执行，执行到这里时，t3休息100毫秒
} catch (InterruptedException e) {
e.printStackTrace();
}
//假设线程按顺序醒过来
//t1线程抢到CPU执行权，在控制台输出：窗口1在出售第1张票
//假设t1继续拥有CPU执行权，执行tickets--操作，tickets = 0；
//t2线程抢到CPU执行权，在控制台输出：窗口2在出售第0张票
//假设t2继续拥有CPU执行权，执行tickets--操作，tickets = -1；
//t3线程抢到CPU执行权，在控制台输出：窗口3在出售第-1张票
//假设t3继续拥有CPU执行权，执行tickets--操作，tickets = -2；
System.out.println(Thread.currentThread().getName()+"在出售第"+tickets+"张票");
tickets--;
}
}
}
}
输出结果：
窗口3在出售第100张票
窗口2在出售第100张票
…
窗口2在出售第1张票
窗口3在出售第1张票
窗口1在出售第-1张票
卖票出现了问题：
- 相同的出现了多次
- 出现了负数的票
问题原因：
- 线程执行的随机性导致的
2.3 数据安全问题
为什么会出现问题？（这也是我们判断多线程程序是否会有数据安全问题的标准）
- 是否是多线程环境
- 是否有共享数据
- 是否有多条语句操作共享数据
如何解决多线程安全问题？
- 基本思想：让程序没有安全问题的环境
怎么实现？
- 把多条语句操作共享数据的代码锁起来，让任意时刻只能有一个线程执行即可
- Java提供了同步代码块的方式解决
2.4 同步代码块
锁多条语句操作共享资源，可以使用同步代码块实现
-
格式：
synchronized(任意对象){
多条语句操作共享数据的代码
} -
synchronized(任意对象)：就相当于给代码加锁了，任意对象就可以看成一把锁
package com.advanced.thread;
public class SellTicketDemo03 {
public static void main(String[] args) {
SellTicket03 st = new SellTicket03();
Thread t1 = new Thread(st, "窗口1");
Thread t2 = new Thread(st, "窗口2");
Thread t3 = new Thread(st, "窗口3");
t1.start();
t2.start();
t3.start();
}
}
class SellTicket03 implements Runnable {
private static int tickets = 100;
private Object obj = new Object();//定义公共锁对象
@Override
public void run() {
while(true){
//tickets = 100;
//t1,t2,t3
//假设t1抢到CPU执行权
//t2线程抢到CPU执行权
// synchronized (new Object()) {//还是会有相同的票，new Object()相当于3个线程都加一把锁，无法真正锁住,需要一把公共锁
synchronized (obj) {
if (tickets > 0) {
try {
//通过sleep()方法模拟出票时间
Thread.sleep(100);
//t1线程休息100毫秒
} catch (InterruptedException e) {
e.printStackTrace();
}
//假设线程按顺序醒过来
//t1线程抢到CPU执行权，在控制台输出：窗口1在出售第100张票
System.out.println(Thread.currentThread().getName() + "在出售第" + tickets + "张票");
tickets--;//tickets = 99;
//如果这三个线程还是按顺序执行，这里就执行了3次tickets--的操作，最终票就变为97
}
}
//t1出来了，这段代码锁就被释放了
}
}
}
输出结果：
窗口1在出售第100张票
窗口3在出售第99张票
窗口2在出售第98张票
…
窗口1在出售第3张票
窗口3在出售第2张票
窗口2在出售第1张票
同步的优点与缺点：
- 优点：解决了多线程数据安全问题
- 缺点：当线程很多时，因为每个线程都会去判断同步上的锁，无形中会降低程序运行效率
2.5 同步方法
同步方法：就是把synchronized关键字加到方法上
-
格式：
修饰符 synchronized 返回值类型 方法名(方法参数){}
-
同步方法的锁对象是什么呢？
- this
同步静态方法：就是就是把synchronized关键字加到静态方法上
-
格式：
修饰符 static synchronized 返回值类型 方法名(方法参数){}
-
同步静态方法的锁对象是什么呢？
- 类名.class
package com.advanced.thread;
public class SellTicketDemo04 {
public static void main(String[] args) {
SellTicket04 st = new SellTicket04();
Thread t1 = new Thread(st, "窗口1");
Thread t2 = new Thread(st, "窗口2");
Thread t3 = new Thread(st, "窗口3");
t1.start();
t2.start();
t3.start();
}
}
class SellTicket04 implements Runnable {
private static int tickets = 100;
private Object obj = new Object();
private int x = 0;
@Override
public void run() {
while (true) {
if (x % 2 == 0) {
// synchronized (obj) {
// synchronized (this) {//同步方法：锁的对象是this
synchronized (SellTicket04.class) {//同步静态方法：锁的对象是类名.class
if (tickets > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "在出售第" + tickets + "张票");
tickets--;
}
}
} else {
// synchronized (obj) {
// if (tickets > 0) {
// try {
// Thread.sleep(100);
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
// System.out.println(Thread.currentThread().getName() + "在出售第" + tickets + "张票");
// tickets--;
// }
// }
sellTicket();
}
x++;
}
}
// private void sellTicket() {
// synchronized (obj) {
// if (tickets > 0) {
// try {
// Thread.sleep(100);
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
// System.out.println(Thread.currentThread().getName() + "在出售第" + tickets + "张票");
// tickets--;
// }
// }
// }
// private synchronized void sellTicket() {//同步方法
// if (tickets > 0) {
// try {
// Thread.sleep(100);
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
// System.out.println(Thread.currentThread().getName() + "在出售第" + tickets + "张票");
// tickets--;
// }
// }
private static synchronized void sellTicket() {//同步静态方法
if (tickets > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "在出售第" + tickets + "张票");
tickets--;
}
}
}
2.6 线程安全的类
StringBuffer
- 线程安全，可变的字符序列
- 从版本JDK 5开始，这个类别已经被一个等级类补充了，这个类被设计为使用一个线程
StringBuilder。StringBuffer应该使用StringBuilder类，因为它支持所有相同的操作，但它更快，因为它不执行同步
Vector
-
Vector类实现了可扩展的对象数组。像数组一样，它包含可以使用整数索引访问的组件。但是Vector的大小可以根据需要增长或缩小，以适应在创建Vector之后添加和删除项目 - 从Java 2平台v1.2，这个类被改造为实现
List接口，使其成为成员Java Collections Framework。与新集合实现不同，Vector是同步的。如果不需要线程安全的实现，建议使用ArrayList代替Vector
Hashtable
- 该类实现了一个哈希表，它将键映射到值。 任何非
null对象都可以用作键值或值 - 从Java 2平台v1.2，这个类被改造为实现
Map接口，使其成为成员Java Collections Framework。与新的集合实现不同，Hashtable是同步的。如果不需要线程安全的实现，建议使用HashMap代替Hashtable。如果需要线程安全的并发实现，那么建议使用ConcurrentHashMap代替Hashtable
package com.advanced.thread;
import java.util.*;
public class ThreadSafeClassDemo {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer();
StringBuilder sb1 = new StringBuilder();
Vector<String> v = new Vector<String>();
ArrayList<String> array = new ArrayList<String>();
Hashtable<String,String> ht = new Hashtable<String, String>();
HashMap<String,String> hm = new HashMap<String, String>();
//StringBuffer Vector Hashtable是线程安全类，多线程时使用StringBuffer,而Vector和Hashtable多线程一不使用
//在Collections类有替代方法：synchronizedList(List<T> list)、synchronizedMap(Map<K,V> m)、synchronizedSet(Set<T> s)
//static <T> List<T> synchronizedList(List<T> list)：返回由指定列表支持的同步（线程安全）列表
List<String> list = Collections.synchronizedList(new ArrayList<String>());
Map<String, String> map = Collections.synchronizedMap(new HashMap<String, String>());
Set<String> set = Collections.synchronizedSet(new HashSet<String>());
}
}
2.7 Lock锁
虽然我们可以理解同步代码块和同步方法的锁对象问题，但我们并没有直接看到在哪里加上了锁，在哪里释放了锁，为了更加清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock
Lock实现提供比synchronized方法和语句可以获得更广泛的锁定操作
Lock中提供了获得锁和释放锁的方法：
- void lock()：获得锁
- void unlock()：释放锁
Lock是接口，不能直接实例化，这里使用它的实现类ReentrantLock来实例化
ReentrantLock的构造方法：
- ReentrantLock()：创建一个ReentrantLock的实例
package com.advanced.thread;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class SellTicketLockDemo {
public static void main(String[] args) {
SellTicketLock s = new SellTicketLock();
Thread t1 = new Thread(s, "窗口1");
Thread t2 = new Thread(s, "窗口2");
Thread t3 = new Thread(s, "窗口3");
t1.start();
t2.start();
t3.start();
}
}
class SellTicketLock implements Runnable{
private static int tickets = 100;
private Lock lock = new ReentrantLock();
@Override
public void run() {
// lock.lock();//IllegalMonitorStateException:抛出以表示线程已尝试在对象的监视器上等待或通知其他线程等待对象的监视器，而不拥有指定的监视器
while(true) {
try {//有可能加锁后代码异常终止导致未释放锁，需要用try...finally...保证一定能释放锁
lock.lock();
if (tickets > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "在出售第" + tickets + "张票");
tickets--;
}
}finally {
lock.unlock();
}
}
// lock.unlock();//Unreachable statement:不可达语句,永远无法执行到此语句
}
}
3.生产者消费者
3.1 生产者消费者模式概述
生产者消费者模式是一个十分经典的多线程协作的模式，弄懂生产者消费者问题能够让我们对对线程编程理解更加深刻
所谓生产者消费者问题，实际上主要包含两类线程：
- 一类是生产者线程用于生产数据
- 一类是消费者线程用于消费数据
为了解决生产者消费者关系，通常会采用共享的数据区域，就像是一个仓库
- 生产者生产数据后直接放置在共享数据区中，并不需要关心消费者的行为
- 消费则只需从共享数据区中获取数据，并不需要关心生产者的行为
生产者 —> 共享数据区 <— 消费者
为了体现生产和消费过程中的等待和唤醒，Java就提供了几个方法供我们使用，这几个方法在Object类中
Object类中等待和唤醒方法：
| 方法名 | 说明 |
|---|---|
| void wait() | 导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法 |
| void notify() | 唤醒正在等待对象监视器的单个线程 |
| void notifyAll() | 唤醒正在等待对象监视器的所有线程 |
3.2 生产者消费者案例
生产者消费者案例中类：
-
奶箱类(Box)：定义一个成员变量，表示第X瓶奶，提供存储牛奶和获取牛奶的操作
-
生产者类(Producer)：实现Runnable接口，重写run()方法，调用存储牛奶的操作
-
消费者类(Customer)：实现Runnable接口，重写run()方法，调用获取牛奶的操作
-
测试类(BoxDemo)：里面有main方法，main方法中代码步骤如下：
① 创建奶箱对象，这是共享数据区
② 创建生产者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用存储牛奶的操作
③ 创建消费者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用获取牛奶的操作
④ 创建两个线程对象，分别把生产者对象和消费者对象作为构造方法参数传递
⑤ 启动线程
package com.advanced.thread;
public class BoxDemo {
public static void main(String[] args) {
//创建奶箱对象，这是共享数据区
Box box = new Box();
//创建生产者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用存储牛奶的操作
Producer p = new Producer(box);
//创建消费者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用获取牛奶的操作
Customer c = new Customer(box);
//创建两个线程对象，分别把生产者对象和消费者对象作为构造方法参数传递
Thread t1 = new Thread(p);
Thread t2 = new Thread(c);
//启动线程
t1.start();
t2.start();
}
}
//奶箱类(Box)
class Box {
//定义一个成员变量，表示第X瓶奶
private static int milk;
//定义一个状态值表示奶箱是否有牛奶
private boolean state = false;
//提供存储牛奶和获取牛奶的操作
public synchronized void put(int milk){
//若奶箱有牛奶，则生产者等待
if (state) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//如果没有牛奶，就生产牛奶
this.milk = milk;
System.out.println("送奶工将第"+this.milk+"瓶牛奶放入奶箱");
//生产之后，改变奶箱状态值
state = true;
//唤醒其他等待的所有线程
notifyAll();
}
public synchronized void get(){
//若奶箱没有牛奶，则消费者等待
if (!state){
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//若有牛奶，就获取牛奶
System.out.println("消费者拿到第"+this.milk+"瓶牛奶");
//消费者获取牛奶后，改变奶箱状态值，并唤醒其他等待的所有线程
state = false;
notifyAll();
}
}
class Producer implements Runnable {
private Box box;
public Producer(Box box) {
this.box = box;
}
@Override
public void run() {
//生产者生产牛奶
for (int i = 1; i <= 5; i++) {
box.put(i);
}
}
}
class Customer implements Runnable {
private Box box;
public Customer(Box box) {
this.box = box;
}
@Override
public void run() {
//消费者循环获取牛奶
while (true) {
box.get();
}
}
}