1.线程安全问题概述
2.模拟卖票代码
//创建一个Runnable接口的实现类
public class RunnableImpl implements Runnable {
//在实现类中重写Runnable接口的run方法，设置线程任务。
//定义一个多线程共享的资源
private int ticket = 100;
//创建一个锁对象
Object obj = new Object();
//重写run方法，设置线程任务
@Override
public void run() {
//使用死循环，让买票操作重复执行
while (true) {
//先判断票是否存在
if(ticket>0){
//提高安全问题出现的频率，让程序睡眠
try{
Thread.sleep(10);
}catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"----"+"正在售卖第"+ticket+"张票");
ticket--;
}
}
}/*模拟卖票案例：创建3个线程，同时开启，对共享的票进行出售*/
public class Demo01Ticket {
public static void main(String[] args) {
//创建Runnable接口的实现类对象
RunnableImpl run = new RunnableImpl();
//创建Thread类对象，构造方法中传递Runnable接口的实现类对象
Thread t0 = new Thread(run);
Thread t1 = new Thread(run);
Thread t2 = new Thread(run);
//调用start方法开启多线程
t0.start();
t1.start();
t2.start();
}
}3.线程安全问题的原理
4.解决线程安全问题-同步代码块
格式：
synchronized(锁对象){
可能会出现线程安全问题的代码（访问了共享数据的代码）}
注意事项：
1.通过代码块中的锁对象，可以使用任意的对象
2.必须要保证多个线程使用的锁对象是同一个
3.锁对象的作用：把同步代码块锁住，只让一个线程在同步代码块中执行。
//创建一个Runnable接口的实现类
public class RunnableImpl implements Runnable {
//在实现类中重写Runnable接口的run方法，设置线程任务。
//定义一个多线程共享的资源
private int ticket = 100;
//创建一个锁对象
Object obj = new Object();
//重写run方法，设置线程任务
@Override
public void run() {
//使用死循环，让买票操作重复执行
while (true) {
synchronized (obj) {
//先判断票是否存在
if (ticket > 0) {
//提高安全问题出现的频率，让程序睡眠
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "----" + "正在售卖第" + ticket + "张票");
ticket--;
}
}
}
}
}5.同步代码块原理
6.解决线程安全问题2-同步方法
/*
解决线程安全问题的第二种方案：使用同步方法
使用步骤：
1.把访问了共享数据的代码抽取出来，放到一个方法中
2.在方法上添加sysnchronized修饰符
格式：定义方法的格式
修饰符 synchronized 返回值类型 方法名（参数列表）{
可能会出现线程安全问题的代码（访问了共享数据的代码）}
同步方法的锁对象：new RunnableImpl1() ,也就是this*/
public class RunnableImpl1 implements Runnable{
private int ticket = 50;
@Override
public void run() {
while (true){
payticket();
}
}
public synchronized void payticket(){
if(ticket>0){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"正在售卖第"+ticket+"张票");
ticket--;
}
}
}7.静态同步方法
public class RunnableImpl2 implements Runnable {
private static int ticket = 30;
@Override
public void run() {
while (true) {
payticket();
}
}
/*静态的同步方法
* 锁对象不是this，this是创建对象之后产生的，静态方法优先于对象
* 静态方法的锁对象是本类的class属性--》class文件对象（反射）*/
public /*synchronized*/static void payticket() {
synchronized (RunnableImpl2.class) {
if (ticket > 0) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "正在售卖第" + ticket + "张票");
ticket--;
}
}
}
}8.解决线程安全问题-lock锁
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.ReentanatLocak implements Lock接口
使用步骤：
1.在成员位置创建一个ReentrantLock对象
2.在可能会出现安全问题的代码前调用Lock接口中的方法lock获取锁
3.在可能会出现安全问题的代码后调用Lock接口中的方法unlock释放锁*/
public class RunnableImpl3 implements Runnable {
private int ticket = 55;
//在成员位置创建一个ReentrantLock对象
Lock l = new ReentrantLock();
@Override
public void run() {
//使用死循环，让买票操作重复执行
while (true) {
//在可能会出现安全问题的代码前调用Lock接口中的方法Lock获取锁
l.lock();
//先判断票是否存在
if (ticket > 0) {
//提高安全问题出现的频率，让程序睡眠
try {
Thread.sleep(10);
System.out.println(Thread.currentThread().getName() + "----" + "正在售卖第" + ticket + "张票");
ticket--;
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
//在可能会出现安全问题的代码后调用Lock接口中的方法unlock释放锁
l.unlock();//无论程序是否异常，都会把锁释放。
}
}
}
}
}9.线程状态概述
10.等待唤醒案例
11.等待唤醒案例代码实现
/*
等待唤醒案例：线程之间的通信
创建一个顾客线程（消费者）：告知老板要的包子的种类和数量，调用wait方法，放弃cpu的执行，进入到waiting状态（无限等待）
创建一个老板线程(生产者）：花了5秒做包子，做好包子之后，调用notify方法，唤醒顾客吃包子
注意：
顾客和老板线程必须使用同步代码块包裹起来，保证等待和唤醒只能有一个在执行
同步使用的锁对象必须保证唯一
只有锁对象才能调用wait和notify()方法
object类中的方法：
void wait()
在其他线程调用此对象的notify()方法或 notifyAll()方法前，导致当前线程等待。
void notify()
唤醒在此对象监视器上等待的单个线程。
会继续执行wait方法之后的代码*/
public class Demo01WaitAndNotify {
public static void main(String[] args) {
//创建锁对象，保证唯一
Object obj = new Object();
//创建一个顾客线程（消费者）
new Thread(){
@Override
public void run() {
synchronized (obj){
System.out.println("告知老板要的包子的种类和数量");
//调用wait方法，放弃cpu的执行，进入到waiting状态（无限等待）
try {
obj.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
//唤醒之后执行的代码
System.out.println("包子已经做好了，开吃。");
}
}
}.start();
//创建一个老板线程（生产者）
new Thread(){
@Override
public void run() {
try {
Thread.sleep(5000);//花费5秒做包子
} catch (InterruptedException e) {
e.printStackTrace();
}
//保证等待和唤醒的线程只能有一个执行，需要使用同步技术
synchronized (obj){
System.out.println("老板5秒钟之后做好了包子，告知顾客，可以吃包子了");
//做好包子之后，调用notify方法，唤醒顾客吃包子
obj.notify();
}
}
}.start();
}
}12.Object类中的wait带参方法和notifyall方法
进入到TimeWaiting(计时等待)有两种方式：
1.使用sleep(long m)方法，在毫秒值结束之后，线程睡眠进入到Runnable/Blocked状态
2.使用wait(long m) 方法，wait方法如果在毫秒值结束之后，还没有被notify唤醒，就会自动醒来，线程睡眠进入到Runnable/Blocked状态
唤醒的方法：
void notify() 唤醒在此对象监视器上等待的单个线程
void notifyAll() 唤醒在此对象监视器上等待的所有线程。
13.线程之间的通信
14.等待唤醒机制概述
15.等待唤醒机制需求分析
16.等待唤醒机制代码分析
public class BaoZi {
String pi;//皮
String xian; //馅
boolean flag = false; //包子的状态：有true,没有false,设置初始值为false没有包子
}
/*
* 生产者（包子铺）类：是一个线程类，可以继承Thread
* 设置线程任务（run）:生产包子*/
public class BaoZiPu extends Thread{
//1.需要在成员位置创建一个包子变量
private BaoZi bz;
//2.使用带参数构造方法，为这个包子变量赋值
public BaoZiPu(BaoZi bz){
this.bz = bz;
}
@Override
public void run() {
//定义一个变量
int count = 0;
while (true){
//必须同时同步技术保证两个线程只能有一个在执行。
synchronized (bz){
if(bz.flag==true) {
//包子铺调用wait方法进入等待状态
try {
bz.wait(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//被唤醒之后执行，包子铺生产包子
//增加一些趣味性：交替生产两种包子
if(count%2==0){
//生产 薄皮包子
bz.pi = "薄皮";
bz.xian = "韭菜鸡蛋";
}else{
bz.pi = "水晶皮";
bz.xian = "牛肉大葱";
}
count++;
System.out.println("包子铺正在生产"+bz.pi+bz.xian+"的包子");
//生产包子需要3秒钟
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//包子铺生产好包子，状态为true
bz.flag = true;
//唤醒吃货线程，让吃货线程吃包子
bz.notify();
System.out.println("包子铺已经生产好了"+bz.pi+bz.xian+",吃货可以开吃了");
}
}
}
}
public class ChiHuo extends Thread{
//1.需要在成员位置创建一个包子变量
private BaoZi bz;
//2.使用带参数构造方法，为这个包子变量赋值
public ChiHuo(BaoZi bz){
this.bz = bz;
}
//设置线程任务（run）:吃包子
@Override
public void run() {
//使用死循环，让吃货一直吃包子
while (true){
//必须同时使用同步技术保证两个线程只能有一个正在执行。
synchronized (bz){
//对包子状态进行判断
if(bz.flag = false){
//吃货调用wait方法进入等待状态
try {
bz.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//被唤醒之后执行的代码
System.out.println("顾客正在吃"+bz.pi+bz.xian+"的包子");
//顾客吃完包子，修改包子的状态
bz.flag = false;
//吃完包子，唤醒包子铺生产包子
bz.notify();
System.out.println("顾客把"+bz.pi+bz.xian+"的包子吃完了，包子铺开始做包子");
System.out.println("------------------------------------");
}
}
}
}
public class Test {
public static void main(String[] args) {
//创建包子对象
BaoZi bz = new BaoZi();
//创建包子铺线程，开启，生产包子
new BaoZiPu(bz).start();
//创建吃货线程，开启吃包子
new ChiHuo(bz).start();
}
}17.线程池底层原理
18.线程池代码实现
