以简单的卖票问题入手
/*
* 模拟卖票案例
* 创建3个线程,同时开启,对共享的票进行出售
* */
public class Demo24Ticket {
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();
}
}
/*
*实现买票案例
* */
public class RunnableImpl 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--;
}
}
}
}
部分实现效果如下
产生后果
- 出现重复票数
- 出现负票情况
情况解析
-
出现负票情况
解析:首先是t0,t1,t3开启了3个线程进行cpu的抢夺,假设t2强到了cpu的执行权,那么t2进入run方法中执行if语句然后进入睡眠模式,失去了cpu的执行权同时,t1,t0也相继进入if失去cpu执行权,t2先醒,假设票为1张,进行–,ticket=0,然后t1,t0相继使用ticket=0,进行–输出ticket=-1,-2这就是出现负票的原因。 -
出现重复票数
解析:t1,t2,t0同时进行到了输出语句,因为进行下一个语句是有时间的,所以它们可以输出一个相同的ticket
解决线程安全问题
方法一:使用同步代码块:
同步技术的原理:
使用一个锁对象,这个锁对象叫同步锁,也叫对象锁,也叫对象监视器 3个线程一起抢夺cpu的执行权,谁抢到谁执行run方法进行卖票
t0抢到了cpu的执行权,执行run方法,遇到synchronized代码块,这时t0会检查synchronized代码块是否有锁对象,发现有,就会获取到锁对象,进入到同步中执行t1抢到了cpu执行权,执行run方法,遇到synchronized代码块这时t1会检查synchronized代码块是否有锁对象
发现没有,t1就会进入到阻塞状态,会一直等待t0线程归还锁对象 一直到t0线程执行完同步中的代码,会把锁对象归还给同步代码块
t1才能获取到锁对象进入到同步中执行总结:同步中的线程,没有执行完毕不会释放锁,同步外的线程没有锁进不去同步
下图解释:
当锁对象obj创建出来,假设t0首先进入死循环,获取了obj对象进入if语句,t1也进入死循环但是,t1无法获取obj对象(obj对象已经被t0获取了),需要等到t0执行完将obj返回,t1才能获取obj对象进入if语句,t3同理;
代码解析:
/*
*买票案例出现了线程安全问题
* 卖出了不存在的票和重复的票
*
* 解决线程安全问题的第一种方案:使用同步代码块
* 格式:
* synchronized(锁对象){
* 可能会出现线程安全问题的代码(访问了共享数据的代码)
* }
*
* 注意:
* 1.通过代码块中的锁对象,可以使用任意对象
* 2.但是我们必须保证多个线程使用的锁对象是同一个
* 3.锁对象作用:
* 把同步代码块锁住,只让一个线程在同步代码块中执行
* */
public class RunnableImpl 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 Demo24Ticket {
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();
}
}
解决线程安全问题的第二种方案:使用同步方法
使用步骤:
1.把访问了共享数据的代码抽取出来,放到一个方法中
2.在方法中添加synchronized修饰符
代码演示:
/*
* 模拟卖票案例
* 创建3个线程,同时开启,对共享的票进行出售
* */
public class Demo24Ticket {
public static void main(String[] args) {
//创建Runnable接口的实现类对象
RunnableImpl run = new RunnableImpl();
System.out.println("run"+run);
//创建Thread类的对象,构造方法中传递Runnable接口的实现类对象
Thread t0 = new Thread(run);
Thread t1 = new Thread(run);
Thread t2 = new Thread(run);
//调用start方法开启多线程
t0.start();
t1.start();
t2.start();
}
}
/*
*解决线程安全问题的第二种方案:使用同步方法
* 使用步骤:
* 1.把访问了共享数据的代码抽取出来,放到一个方法中
* 2.在方法中添加synchronized修饰符
*
* 格式:定义方法的格式
* 修饰符 synchronized 返回值类型 方法名(参数列表){
* 访问了共享数据代码
* }
* */
public class RunnableImpl implements Runnable {
//定义一个多个线程共享的票源
private int ticket = 100;
//设置线程任务:卖票
@Override
public void run() {
System.out.println("this"+this);
//使用死循环,让卖票操作重复执行
while (true){
payTicket();
}
}
/*
* 定义一个同步方法
* 同步方法也会把方法内部的代码锁住
* 只让一个线程执行
* 同步方法的锁对象是谁?
* 就是我们的实现类对象 new RunnableImpl()
* 也就是this
* */
public synchronized void payTicket(){
//先判断票是否存在
if (ticket>0){
//提高安全问题出现的概率,让程序睡眠
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
//票存在,卖票 ticket
System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
ticket--;
}
}
}
静态同步方法代码解析:
/*
*解决线程安全问题的第二种方案:使用同步方法
* 使用步骤:
* 1.把访问了共享数据的代码抽取出来,放到一个方法中
* 2.在方法中添加synchronized修饰符
*
* 格式:定义方法的格式
* 修饰符 synchronized 返回值类型 方法名(参数列表){
* 访问了共享数据代码
* }
* */
public class RunnableImpl implements Runnable {
//定义一个多个线程共享的票源
private static int ticket = 100;
//设置线程任务:卖票
@Override
public void run() {
System.out.println("this"+this);
//使用死循环,让卖票操作重复执行
while (true){
payTicketStatic();
}
}
/*
* 静态的同步方法
* 锁对象是谁?
* 不能是this
* this是创建对象之后产生的,静态方法优先于对象
* 静态方法的锁对象是本类的class属性-->class文件对象(反射)
* */
public static synchronized void payTicketStatic(){
//先判断票是否存在
if (ticket>0){
//提高安全问题出现的概率,让程序睡眠
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
//票存在,卖票 ticket
System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
ticket--;
}
}
/*
* 定义一个同步方法
* 同步方法也会把方法内部的代码锁住
* 只让一个线程执行
* 同步方法的锁对象是谁?
* 就是我们的实现类对象 new RunnableImpl()
* 也就是this
* */
public synchronized void payTicket(){
//先判断票是否存在
if (ticket>0){
//提高安全问题出现的概率,让程序睡眠
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
//票存在,卖票 ticket
System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
ticket--;
}
}
}
/*
* 模拟卖票案例
* 创建3个线程,同时开启,对共享的票进行出售
* */
public class Demo24Ticket {
public static void main(String[] args) {
//创建Runnable接口的实现类对象
RunnableImpl run = new RunnableImpl();
System.out.println("run"+run);
//创建Thread类的对象,构造方法中传递Runnable接口的实现类对象
Thread t0 = new Thread(run);
Thread t1 = new Thread(run);
Thread t2 = new Thread(run);
//调用start方法开启多线程
t0.start();
t1.start();
t2.start();
}
}
第三种方式Lock锁:
代码演示:
/*
* 模拟卖票案例
* 创建3个线程,同时开启,对共享的票进行出售
* */
public class Demo24Ticket {
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();
}
}
/*
*解决安全问题的第三种方式:使用lock锁
* java.util.concurrent.locks.lock接口
* Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。
*
* void lock()获取锁。
* void unlock() 释放锁。
*java.util.concurrent.locks.ReentrantLock implements Lock接口
*
* 使用步骤:
* 1.在成员位置创建一个实现类对象ReentrantLock对象
* 2.在可能会出现安全问题的代码前调用Lock接口中的方法Lock获取锁
* 3.在可能会出现安全问题的代码后调用Lock接口中的方法unLock释放锁
*
* */
public class RunnableImpl 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();//无论程序是否出现异常锁都将释放
}
}
}
}
}