java的线程、多线程、线程安全、锁机制、Thread类
线程
多线程
我们在之前，学习的程序在没有跳转语句的前提下，都是由上至下依次执行，那现在想要设计一个程序，边打游戏边听歌，怎么设计?
要解决上述问题，咱们得使用多进程或者多线程来解决
并发与并行
- 并发:指两个或多个事件在同一个时间段内发生
- 并行:指两个或多个事件在同一时刻发生(同时发生)。
线程与进程
- 进程:是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程;进程也是程序的一次执行过程，是系统运行程序的基本单位:系统运行一个程序即是一个进程从创建运行到消亡的过程。
- 线程:线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
简而言之:一个程序运行后至少有一个进程，一个进程中可以包含多个线程
进程的概念
线程的概念
线程的调度
- 分时调度
所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间。 - 抢占式调度
优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。
抢占式调度详解
创建线程类
Java使用java.lang.Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。每个线程的作用是完成一定的任务，实际上就是执行一段程序流即一段顺序执行的代码。Java使用线程执行体来代表这段程序流。 Java中通过继承Thread类来创建并启动多线程的步骤如下:
- 定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务,因此把
run()方法称为线程执行体。 - 创建Thread子类的实例，即创建了线程对象
- 调用线程对象的start()方法来启动该线程
主线程（创建多线程的第一种方式）
/*
主线程：执行主方法(main)方法的线程
单线程程序：java程序只有一个线程
执行从main方法开始，从上到下依次执行
JVM执行main方法，main方法会进入到栈内存
JVM会找操作系统开辟一条main方法通向cpu的执行路径
cpu就会通过这个路径来执行main方法
而这个路径有一个名字，叫main(主)线程
*/
public class Demo01MainThread {
public static void main(String[] args) {
Person p1 = new Person("小强");
p1.run();
System.out.println(0/0);//ArithmeticException: / by zero
Person p2 = new Person("旺财");
p2.run();
}
}
public class Person {
private String name;
public void run(){
//定义循环，执行20次
for (int i = 0; i < 20; i++) {
System.out.println(name + "-->" + i);
}
}
public Person() {
}
public Person(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
/*
创建多线程程序的第一种方式：创建Thread类的子类
java.lang.Thread类：是描述线程的类，我们想要实现多线程程序，就必须继承Thread类
实现步骤：
1.创建一个Thread类的子类
2.在Thread的子类中重写Thread类中的run方法，设置线程任务(开启线程要做什么？)
3.创建Thread类的子类对象
4.调用Thread类中的方法start方法，开启新的线程，执行run方法
void start() 使该线程开始执行；java虚拟机调用该线程的run方法
结果是两个线程并发地运行；当前线程(main线程)和另一个线程(创建的新线程，执行其run方法)
多次启动一个线程是非法的。特别是当线程已经结束执行后，不能再重新启动
java程序属于抢占式调度，哪个线程的优先级高，哪个先喝茶呢个优先执行；同一个优先级，随机选择一个执行
*/
public class Demo01Thread {
public static void main(String[] args) {
//3.创建Thread类的子类对象
MyThread mt = new MyThread();
//4.调用Thread类中的方法start方法，开启新的线程，执行run方法
mt.start();
for (int i = 0; i < 20; i++) {
System.out.println("main:" + i);
}
}
}
//1.创建一个Thread类的子类
public class MyThread extends Thread{
// 2.在Thread的子类中重写Thread类中的run方法，设置线程任务(开启线程要做什么？)
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println("run:" + i);
}
}
}
多线程原理
多线程的内存图解
Thread类常用方法
API中该类中定义了有关线程的一些方法，具体如下
构造方法:
public Thread():分配一个新的线程对象public Thread(String name):分配一个指定名字的新的线程对象。public Thread(Runnable target):分配一个带有指定目标新的线程对象public Thread(Runnable target,String name):分配一个带有指定目标新的线程对象并指定名字。
常用方法:
public String getName():获取当前线程名称。public void start():导致此线程开始执行;Java虚拟机调用此线程的run方法。public void run():此线程要执行的任务在此处定义代码。public static void sleep(long millis):使当前正在执行的线程以指定的毫秒数暂停(暂时停止执行)。public static Thread currentThread():返回对当前正在执行的线程对象的引用。
翻阅API后得知创建线程的方式总共有两种，一种是继承Thread类方式，一种是实现Runnable接口方式，接下来讲解方式二实现的方式。
获取线程名称的两种方式
MyThread2.java
/*
获取线程的名称：
1.使用Thread类中的方法getName()
String getName() 返回该线程的名称，
2.可以先获取到当前正在执行的线程，使用线程中的方法getName()获取线程的名称
static Thread currentThread() 返回对当前正在执行的线程对象的引用
*/
//定义一个Thread的子类
public class MyThread2 extends Thread{
//重写Thread类中的run方法，设置线程任务
@Override
public void run() {
//获取线程名称
//String name = getName();
//System.out.println(name);
//Thread t = Thread.currentThread();
//System.out.println(t);//Thread[Thread-1,5,main]
//String name = t.getName();
//System.out.println(name);
//链式编程
System.out.println(Thread.currentThread().getName());
}
}
Demo02GetThreadName.java
/*
线程的名称：
主线程：main
新线程：Thread-0.Thread-1，Thread-2...
*/
public class Demo02GetThreadName {
public static void main(String[] args) {
//创建Thread类的子类对象
MyThread2 mt = new MyThread2();
//调用start方法，开启新线程，执行run方法
mt.start();
new MyThread2().start();
new MyThread2().start();
//链式编程
System.out.println(Thread.currentThread().getName());
}
}
设置线程名称的两种方式
MyThread3.java
/*
设置线程的名称(了解):
1.使用Thread类中的方法setName(名字)
void setName(String name) 改变线程名称，使之与参数 name相同。
2.创建一个带参数的构造方法，参数传递线程的名称；调用父类的带参构造方法，把线程名称传递给父类，让父类(Thread)给子线程起一个名字
Thread(String name) 分派心得Thread 对象。
*/
public class MyThread3 extends Thread{
public MyThread3(){
}
public MyThread3(String name){
super(name);//把线程名称传递给父类，让父类(Thread)给子线程起一个名字
}
@Override
public void run() {
//获取线程的名称
System.out.println(Thread.currentThread().getName());
}
}
Demo03SetThreadName.java
public class Demo03SetThreadName {
public static void main(String[] args) {
//开启多线程
MyThread3 mt = new MyThread3();
mt.setName("小强");
mt.start();
//开启多线程
new MyThread3("旺财").start();
}
}
线程的sleep方法
/*
public static void sleep(long millis):使当前正在执行的线程以指定的毫秒数暂停(暂时停止执行)。
毫秒数结束之后，线程继续执行
*/
public class Demo04Sleep {
public static void main(String[] args) {
//模拟秒表
for (int i = 1; i <= 60; i++) {
System.out.println(i);
//使用Thread类的sleep方法让程序睡眠1秒钟
try{
Thread.sleep(1000);
}catch (InterruptedException e){
e.printStackTrace();
}
}
}
}
创建多线程的第二种方式(Runnable)
采用 java.lang.Runnable 也是非常常见的一种，我们只需要重写run方法即可
步骤如下
- 定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
- 创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的
线程对象。 - 调用线程对象的start()方法来启动线程
Demo05Runnable.java
/*
创建多线程程序的第二种方法：实现Runnable接口
java.lang.Runnable
Runnable 接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个成为run的无参数方法
java.lang.Thread类的构造方法
Thread(Runnable target) 分配新的Thread 对象
Thread(Runnable target, String name) 分配新的Thread 对象
实现步骤：
1.创建一个Runnable接口的实现类
2.在实现类中重写Runnable接口的run方法，设置线程任务
3.创建一个Runnable接口的实现类对象
4.创建Thread类对象，构造方法中传递Runnable接口的实现类对象
5.调用Thread类中的start方法，开启新的线程执行run方法
*/
public class Demo05Runnable {
public static void main(String[] args) {
//3.创建一个Runnable接口的实现类对象
RunnableImpl run = new RunnableImpl();
//4.创建Thread类对象，构造方法中传递Runnable接口的实现类对象
Thread t = new Thread(run);
//5.调用Thread类中的start方法，开启新的线程执行run方法
t.start();
for (int i = 0; i < 20; i++) {
System.out.println(Thread.currentThread().getName() + "-->" + i);
}
}
}
RunnableImpl.java
//.创建一个Runnable接口的实现类
public class RunnableImpl implements Runnable{
//2.在实现类中重写Runnable接口的run方法，设置线程任务
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println(Thread.currentThread().getName() + "-->" + i);
}
}
}
Thread和Runnable的区别
如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享
总结：
实现Runnable接口比继承Thread类所具有的优势
- 适合多个相同的程序代码的线程去共享同一个资源
- 可以避免java中的单继承的局限性。
- 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
- 4线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类
扩充:在iava中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用 java命令执行一个类的时候，实际上都会启动一个JVM，每一个VM其实在就是在操作系统中启动了一个进程。
匿名内部类方法实现线程的创建
/*
匿名内部类方法实现线程的创建
匿名：没有名字
内部类：写在其他类内部的类
匿名内部类作用：简化代码
把子类继承父类，重写父类的方法，创建子类对象合成一步完成
把实现类实现类接口，重写接口中的方法，创建实现类对象合成一步完成
匿名内部类的最终产物：子类/实现类对象，而这个类没有名字
格式：
new 父类/接口(){
重写父类/接口中的方法
};
*/
public class Demo06InnerClassThread {
public static void main(String[] args) {
//线程的父类是Thread
// new MyThread().start();
new Thread(){
//重写run方法，设置线程任务
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println(Thread.currentThread().getName() + "-->" + "zxl");
}
}
}.start();
//线程的接口Runnbale
//Runnable r = new RunnableImpl();//多态
Runnable r = new Runnable(){
//重写润方法，设置线程任务
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println(Thread.currentThread().getName() + "-->" + "ZXL");
}
}
};
new Thread(r).start();
//简化接口的方式
new Thread(new Runnable(){
//重写润方法，设置线程任务
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println(Thread.currentThread().getName() + "-->" + "good");
}
}
}).start();
}
}
线程安全
线程安全
RunnableImpl2.java
/*
实现卖票案例
*/
public class RunnableImpl2 implements Runnable {
//定义一个多个线程共享的票源
private int ticket = 100;
//设置线程任务卖票
@Override
public void run() {
//使用死循环，让卖票操作重复执行
while(true){
//先判断票是否存在
if(ticket > 0){
//提高安全问题出现的概率，让程序睡眠
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
//票存在，卖票 ticket--
System.out.println(Thread.currentThread().getName() + "-->正在卖第" + ticket + "张票");
ticket--;
}
}
}
}
Demo07Ticket.java
/*
模拟卖票案例
创建3个线程，同时开启，对贡献的票进行出售
*/
public class Demo07Ticket {
public static void main(String[] args) {
//创建Runnable接口的实现类对象
RunnableImpl2 run = new RunnableImpl2();
//创建Thread类对象，构造方法中床底RUN你罢了接口的实现类对象
Thread t0 = new Thread(run);
Thread t1 = new Thread(run);
Thread t2 = new Thread(run);
//调用start方法开启多线程
t0.start();
t1.start();
t2.start();
}
}
线程安全问题产生原理
线程同步
为了保证每个线程都能正常执行原子操作Java引入了线程同步机制。那么怎么去使用呢?有三种方式完成同步操作:
- 同步代码块
- 同步方法。
- 锁机制。
同步代码块
- 同步代码块 ：
synchronized关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问
格式：
synchronized(同步锁){
需要同步操作的代码
}
同步锁：
对象的同步锁只是一个概念，可以想象为在对象上标记了一个锁
- 锁对象可以是任意类型。
- 多个线程对象要使用同一把锁。
注意：在任何时候，最多允许一个线程拥有同步锁，谁拿到锁就进入代码块，其他的线程只能在外等着(BLOCKED)。
/*
卖票案例出现了安全问题
卖出了不存在的票和重复的票
解决线程安全问题的一种方案：使用同步代码块
格式：
synchronized(锁对象){
可能会出现线程安全问题的代码(访问了共享数据的代码)
}
注意：
1.通过代码块中的锁的对象，可以使用任意的对象
2.但是必须保证多个线程使用的锁对象是同一个
3.锁对象作用：
把同步代码锁住，只让一个线程在同步代码块中执行
*/
public class RunnableImpl22 implements Runnable {
//定义一个多个线程共享的票源
private int ticket = 100;
//创建一个锁对象
Object obj = new Object();
//设置线程任务卖票
@Override
public void run() {
//使用死循环，让卖票操作重复执行
while(true){
//同步代码块
synchronized (obj){
//先判断票是否存在
if(ticket > 0){
//提高安全问题出现的概率，让程序睡眠
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
//票存在，卖票 ticket--
System.out.println(Thread.currentThread().getName() + "-->正在卖第" + ticket + "张票");
ticket--;
}
}
}
}
}
/*
模拟卖票案例
创建3个线程，同时开启，对贡献的票进行出售
*/
public class Demo07Ticket2 {
public static void main(String[] args) {
//创建Runnable接口的实现类对象
RunnableImpl22 run = new RunnableImpl22();
//创建Thread类对象，构造方法中床底RUN你罢了接口的实现类对象
Thread t0 = new Thread(run);
Thread t1 = new Thread(run);
Thread t2 = new Thread(run);
//调用start方法开启多线程
t0.start();
t1.start();
t2.start();
}
}
同步方法
- 同步方法:使用synchronized修饰的方法，就叫做同步方法,保证A线程执行该方法的时候，其他线程只能在方法外等着。
格式:
public synchronized void method(){
}
可能会产生线程安全问题的代码
}
同步锁是谁?
对于非static方法,同步锁就是this 对于static方法我们使用当前方法所在类的字节码对象(类名.class)。
/*
卖票案例出现了安全问题
卖出了不存在的票和重复的票
解决线程安全问题的二种方案：使用同步方法
使用步骤：
1.把访问了共享数据的代码抽取出来，放在一个方法中
格式：定义方法的格式
修饰符 synchronized 返回值类型 方法名(参数列表){
可能会出现线程安全问题的代码(访问了共享数据的代码)
}
*/
public class RunnableImpl23 implements Runnable {
//定义一个多个线程共享的票源
private int ticket = 100;
//创建一个锁对象
Object obj = new Object();
//设置线程任务卖票
@Override
public void run() {
//使用死循环，让卖票操作重复执行
while(true){
payTicket();
}
}
/*
定义一个同步方法
同步方法也会把方法内部的代码锁住
只让一个线程执行
同步方法的锁对象是谁？
就是实现类对象 new RunnableImpl23
也就是this
*/
public /*synchronized*/ void payTicket(){
synchronized (this) {
//先判断票是否存在
if (ticket > 0) {
//提高安全问题出现的概率，让程序睡眠
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
//票存在，卖票 ticket--
System.out.println(Thread.currentThread().getName() + "-->正在卖第" + ticket + "张票");
ticket--;
}
}
}
}
/*
模拟卖票案例
创建3个线程，同时开启，对贡献的票进行出售
*/
public class Demo07Ticket3 {
public static void main(String[] args) {
//创建Runnable接口的实现类对象
RunnableImpl23 run = new RunnableImpl23();
//创建Thread类对象，构造方法中床底RUN你罢了接口的实现类对象
Thread t0 = new Thread(run);
Thread t1 = new Thread(run);
Thread t2 = new Thread(run);
//调用start方法开启多线程
t0.start();
t1.start();
t2.start();
}
}
静态同步方法（了解）
public class RunnableImpl23 implements Runnable {
//定义一个多个线程共享的票源
private static int ticket = 100;
//创建一个锁对象
Object obj = new Object();
//设置线程任务卖票
@Override
public void run() {
//使用死循环，让卖票操作重复执行
while(true){
payTicketStatic();
}
}
/*
静态的同步方法
锁对象是谁？
不能是this
this是创建对象之后产生的，静态方法优先于对象
静态方法的锁对象是本类的class属性-->class文件对象(反射)
*/
public static /*synchronized*/ void payTicketStatic(){
synchronized (RunnableImpl23.class) {
//先判断票是否存在
if (ticket > 0) {
//提高安全问题出现的概率，让程序睡眠
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
//票存在，卖票 ticket--
System.out.println(Thread.currentThread().getName() + "-->正在卖第" + ticket + "张票");
ticket--;
}
}
}
}
public class Demo07Ticket3 {
public static void main(String[] args) {
//创建Runnable接口的实现类对象
RunnableImpl23 run = new RunnableImpl23();
//创建Thread类对象，构造方法中床底RUN你罢了接口的实现类对象
Thread t0 = new Thread(run);
Thread t1 = new Thread(run);
Thread t2 = new Thread(run);
//调用start方法开启多线程
t0.start();
t1.start();
t2.start();
}
}
Lock锁(JDK1.5之后)
java.util.concurrent.locks.Lock机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作同步代码块/同步方法具有的功能Lock都有除此之外更强大，更体现面向对象。
Lock锁也称同步锁，加锁与释放锁方法化了，如下:
public void lock():加同步锁。public void unlock():释放同步锁。
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/*
卖票案例出现了安全问题
卖出了不存在的票和重复的票
解决线程安全问题的三种方案：使用Lock锁
java.util.concurrent.locks.Lock接口
Lock 实现提供了比使用 synchronized方法和语句可获得更广泛的锁定操作。
Lock 接口中的方法：
void Lock() 获取锁。
void unLock() 释放锁。
java.util.concurrent.locks.ReentrantLock implements Lock接口
使用步骤：
1.在成员位置创建一个ReentrantLock对象
2.在可能会出现安全问题的代码前调用Lock接口中的方法Lock获取锁
3.在可能会出现安全问题的代码后调用Lock接口中的方法unLock释放锁
*/
public class RunnableImpl24 implements Runnable {
//定义一个多个线程共享的票源
private int ticket = 100;
//1.在成员位置创建一个ReentrantLock对象
Lock l = new ReentrantLock();
//设置线程任务卖票
@Override
public void run() {
//使用死循环，让卖票操作重复执行
while(true){
//2.在可能会出现安全问题的代码前调用Lock接口中的方法Lock获取锁
l.lock();
//先判断票是否存在
if(ticket > 0){
//提高安全问题出现的概率，让程序睡眠
try {
Thread.sleep(10);
//票存在，卖票 ticket--
System.out.println(Thread.currentThread().getName() + "-->正在卖第" + ticket + "张票");
ticket--;
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
//3.在可能会出现安全问题的代码后调用Lock接口中的方法unLock释放锁
l.unlock();//无论程序是否异常，都会把锁释放
}
}
}
}
/*//设置线程任务卖票
@Override
public void run() {
//使用死循环，让卖票操作重复执行
while(true){
//2.在可能会出现安全问题的代码前调用Lock接口中的方法Lock获取锁
l.lock();
//先判断票是否存在
if(ticket > 0){
//提高安全问题出现的概率，让程序睡眠
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
//票存在，卖票 ticket--
System.out.println(Thread.currentThread().getName() + "-->正在卖第" + ticket + "张票");
ticket--;
}
//3.在可能会出现安全问题的代码后调用Lock接口中的方法unLock释放锁
l.unlock();
}
}*/
}
/*
模拟卖票案例
创建3个线程，同时开启，对贡献的票进行出售
*/
public class Demo07Ticket4Lock {
public static void main(String[] args) {
//创建Runnable接口的实现类对象
RunnableImpl24 run = new RunnableImpl24();
//创建Thread类对象，构造方法中床底RUN你罢了接口的实现类对象
Thread t0 = new Thread(run);
Thread t1 = new Thread(run);
Thread t2 = new Thread(run);
//调用start方法开启多线程
t0.start();
t1.start();
t2.start();
}
}
线程状态
线程状态概述
线程的状态图
Timed Waiting（计时等待）
TimedWaiting在AP中的描述为:一个正在限时等待另一个线程执行一个(唤醒)动作的线程处于这一状态。
在写卖票的案例中，为了减少线程执行太快，现象不明显等问题，在run方法中添加了sleep语句，这样就强制当前正在执行的线程休眠(暂停执行)，以“减慢线程”
其实当我们调用了sleep方法之后，当前执行的线程就进入到“休眠状态”，其实就是所谓的Timed Waiting(计时等待)
Timed Waiting线程状态图
BLOCKED（锁阻塞）
Blocked状态在API中的介绍为:一个正在阻塞等待一个监视器锁(锁对象)的线程处于这一状态。
学完同步机制，这个状态是非常好理解的了。比如，线程A与线程B代码中使用同一锁，如果线程A获取到锁，线程A进入到Runnable状态，那么线程B就进入到Blocked锁阻塞状态。
这是由Runnable状态进入Blocked状态。除此Waiting以及Time Waiting状态也会在某种情况下进入阻塞状态，而这部分内容作为扩充知识点带领大家了解一下。
Blocked线程状态图
Waiting（无限等待）
Wating状态在API中介绍为:一个正在无限期等待另一个线程执行一个特别的(唤醒)动作的线程处于这一状态。
案例演示
代码实现
/*
等待唤醒案例：线程之间的通信
创建一个顾客线程(消费者)：告知老板要的包子的种类和数量，调用wait方法，放弃cpu的执行，进入到WAITING状态(无限等待)
创建一个老板线程(生产者)：花了5秒做包子，做好包子之后，代用notify方法，唤醒顾客吃包子
注意：
顾客和老板线程必须使用同步代码快包裹起来，保证等待和唤醒只能一个在执行
同步使用的锁对象必须保证唯一
只有锁对象才能调用wait和notify方法
Object类中的方法
void wait()
在其他线程调用此对象的notify()方法或notifyAll()方法前，导致当前线程等待
void notify()
唤醒在此对象监视器上等待的单个线程
会继续执行wait方法之后的代码
*/
public class demo08WaitAndNotify {
public static void main(String[] args) {
//创建锁对象，保证唯一
Object obj = new Object();
//创建一个顾客线程(消费者)
new Thread(){
@Override
public void run() {
//一直等着买包子
while (true){
//保证等待和唤醒的线程只能有一个在执行
synchronized (obj){
System.out.println("告知老板要的包子的种类和数量");
//调用wait方法，放弃cpu的执行，进入到WAITING状态(无限等待)
try{
obj.wait();
}catch (InterruptedException e){
e.printStackTrace();
}
//唤醒之后执行的代码
System.out.println("包子已经做好了，开吃！");
System.out.println("=========================");
}
}
}
}.start();
//创建一个老板线程(生产者)
new Thread(){
@Override
public void run() {
//一直做包子
while(true){
try{
Thread.sleep(5000);//花5秒做包子
}catch (InterruptedException e){
e.printStackTrace();
}
synchronized (obj){
System.out.println("老板5秒中之后做好包子，告知顾客，可以吃包子了！");
//做好包子之后，代用notify方法，唤醒顾客吃包子
obj.notify();
}
}
}
}.start();
}
}
/*
进入到TimeWaiting(计时等待)有两种方法
1.使用sleep(Long m)方法，在毫秒值结束之后，线程睡醒进入到Runnable/Blocked状态
2.使用wait(Long m)方法，wait方法如果在毫秒值结束之后，还没有被notify唤醒，就会自动醒来
唤醒的方法：
void notify() 唤醒在此对象监控器上等待的单个线程
void notifyAll() 唤醒在此对象监控器上等待的所有线程
*/
public class demo08WaitAndNotify2 {
public static void main(String[] args) {
//创建锁对象，保证唯一
Object obj = new Object();
//创建一个顾客线程(消费者)
new Thread() {
@Override
public void run() {
//一直等着买包子
while (true) {
//保证等待和唤醒的线程只能有一个在执行
synchronized (obj) {
System.out.println("顾客1告知老板要的包子的种类和数量");
//调用wait方法，放弃cpu的执行，进入到WAITING状态(无限等待)
try {
obj.wait(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//唤醒之后执行的代码
System.out.println("包子已经做好了，顾客1开吃！");
System.out.println("=========================");
}
}
}
}.start();
//创建一个顾客线程(消费者)
new Thread() {
@Override
public void run() {
//一直等着买包子
while (true) {
//保证等待和唤醒的线程只能有一个在执行
synchronized (obj) {
System.out.println("顾客2告知老板要的包子的种类和数量");
//调用wait方法，放弃cpu的执行，进入到WAITING状态(无限等待)
try {
obj.wait(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//唤醒之后执行的代码
System.out.println("包子已经做好了，顾客2开吃！");
System.out.println("=========================");
}
}
}
}.start();
//创建一个老板线程(生产者)
new Thread(){
@Override
public void run() {
//一直做包子
while(true){
try{
Thread.sleep(5000);//花5秒做包子
}catch (InterruptedException e){
e.printStackTrace();
}
synchronized (obj){
System.out.println("老板5秒中之后做好包子，告知顾客，可以吃包子了！");
//做好包子之后，代用notify方法，唤醒顾客吃包子
//obj.notify();//如果有多个线程等待，随机唤醒一个
obj.notifyAll();//唤醒所有等待的线程
}
}
}
}.start();
}
}