目录
多线程实现的方案一：继承Thread
1.自定义一个类extends Thread
2.重写run()里面写业务
3.创建线程对象
4.调用start()
注意：可以通过调用父类Thread的含参构造Thread(String name)
给自定义线程对象起名字，调用方式：super(name);
构造方法摘要
Thread() 创建一个新的线程对象，名字是系统自定义的
Thread(String name) 与上面功能一致，还可以自定义线程名
package cn.tedu.tickets;
/*本类用于改造多线程售票案例，解决数据安全问题*/
public class TestThreadV2 {
public static void main(String[] args) {
//5.创建多个线程对象并以多线程的方式运行
TickectT2 t1 = new TickectT2();
TickectT2 t2 = new TickectT2();
TickectT2 t3 = new TickectT2();
TickectT2 t4 = new TickectT2();
t1.start();
t2.start();
t3.start();
t4.start();
}
}
//1.自定义多线程类
class TickectT2 extends Thread {
//3.新增成员变量用来保存票数
static int tickets = 100;
//static Object o = new Object();
//2.添加重写的run()来完成业务
@Override
public void run() {
//3.创建循环结构用来卖票
while (true) {
//Ctrl+Alt+L调整代码缩进
//7.添加同步代码块，解决数据安全问题
//synchronized (new Object()) {
/*static的Object的对象o这种写法也可以*/
//synchronized (o) {
/*我们每通过class关键字创建一个类，
/*就会在工作空间中生成一个唯一对应的类名.class字节码文件
/* 这个类名.class对应的对象我们称之为这个类的字节码对象
/* 字节码对象极其重要，是反射技术的基石，字节码对象中包含了当前类所有的关键信息
/* 所以，用这样一个唯一且明确的对象作为同步代码块的锁对象，再合适不过了*/
synchronized (TickectT2.class) {/*比较标准的写法*/
if(tickets > 0){ //加多个判断,锁加判断解除了重买、超卖的问题, (双重校验)
//6.添加线程休眠，暴露问题
try {
Thread.sleep(10);//让线程休眠，增加线程状态切换的频率
} catch (InterruptedException e) {
e.printStackTrace();
}
//4.1打印当前正在售票的线程名与票数-1
System.out.println(getName() + "=" + tickets--);
}
//4.2给程序设置一个出口，没有票的时候就停止卖票
if (tickets <= 0) break;
}
}
}
}
多线程实现的方案二：实现Runnable
1.自定义一个类implements Runnable
2.实现接口中未实现的run()
3.打印线程名称：Thread.currentThread().getName()
4.创建目标业务对象–接口实现类的对象–包含的是我们的业务
5.创建线程对象–Thread t1 = new Thread(target);
目的：为了把实现类与Thread建立关系，原因是想用Thread的start()
6.通过线程对象调用start(),把线程对象加入就绪队列
构造方法摘要
Thread(Runnable target) 创建一个线程对象，参数为Runnable实现类的对象
Thread(Runnable target, String name) 与上面功能一致，还可以自定义线程名
虽然方案二写法较为复杂，但是方案二的优点如下：
- 耦合性不强，没有继承，后续仍然可以继承
- 采用实现接口的方式，后续仍然可以实现其他接口
- 可以给所有线程对象统一业务，业务保持一致
- 面向接口编程，代码更高级
package cn.tedu.tickets;
/*本类用于改造多线程售票案例，解决数据安全问题*/
public class TestRunnableV2 {
public static void main(String[] args) {
//5.创建目标业务类对象
TicketR2 target = new TicketR2();
//6.创建线程对象
Thread t1 = new Thread(target);
Thread t2 = new Thread(target);
Thread t3 = new Thread(target);
Thread t4 = new Thread(target);
//7.以多线程的方式运行
t1.start();
t2.start();
t3.start();
t4.start();
}
}
/*1.多线程中出现数据安全问题的原因：多线程程序+共享数据+多条语句操作共享数据*/
/*2.同步锁：相当于给容易出现问题的代码加了一把锁，包裹了所有可能会出现数据安全问题的代码
* 加锁之后，就有了同步(排队)的效果，但是加锁的话，需要考虑：
* 锁的范围：不能太大，太大，干啥都得排队，也不能太小，太小，锁不住，还是会有安全隐患*/
//1.创建自定义多线程类
class TicketR2 implements Runnable {
//3.定义成员变量，保存票数
int tickets = 100;
//创建锁对象
Object o = new Object();
//2.实现接口中未实现的方法，run()中放着的是我们的业务
@Override
public void run() {
//4.通过循环结构完成业务
while (true) {
/*3.同步代码块：synchronized(锁对象){会出现安全隐患的所有代码}
* 同步代码块在同一时刻，同一资源只会被一个线程独享*/
/*这种写法不对，相当于每个线程进来的时候都会new一个锁对象，线程间使用的并不是同一把锁*/
//synchronized (new Object()){
//修改同步代码块的锁对象为成员变量o,因为锁对象必须唯一
synchronized (o) {//同步代码块解决的是重卖的问题
//如果票数>0就卖票
if (tickets > 0){ //加多个判断,锁加判断解除了重买、超卖的问题, (双重校验)
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
//4.1打印当前正在售票的线程名以及票数-1
System.out.println(Thread.currentThread().getName() + "=" + tickets--);
}
//4.2退出死循环--没票的时候就结束
if (tickets <= 0) break;
}
}
}
}
多线程实现的方案三：线程池ExecutorService
Executors是用来辅助创建线程池的工具类对象
常用方法是newFixedThreadPool(int)
这个方法可以创建指定线程数目的线程池对象
创建出来的线程池对象是ExecutorService:用来存储线程的池子，负责：新建/启动/关闭线程
execute()让线程池中的线程来执行业务，每次调用都会将一个线程加入到就绪队列
package cn.tedu.tickets;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/*本类用于测试线程池*/
public class TestThreadPool {
public static void main(String[] args) {
//5.创建接口实现类TicketR3类的对象作为目标业务对象
TicketR3 target = new TicketR3();
/*Executors是用来辅助创建线程池的工具类对象
* 常用方法是newFixedThreadPool(int)这个方法可以创建指定数目的线程池对象
* 创建出来的线程池对象是ExecutorService:用来存储线程的池子，负责：新建/启动/关闭线程*/
//6.使用Executors工具创建一个最多有5个线程的线程池对象ExecutorService池对象
ExecutorService pool = Executors.newFixedThreadPool(5);
for (int i = 0; i < 5; i++) {
/*execute()让线程池中的线程来执行业务，每次调用都会将一个线程加入到就绪队列*/
pool.execute(target);/*本方法的参数就是你要执行的业务，也就是目标业务类对象*/
}
}
}
//同步锁问题解决方案笔记：1.4.1从26行复制到58行，TicketR2改成TicketR3
//1.创建自定义多线程类
class TicketR3 implements Runnable {
//3.定义成员变量，保存票数
int tickets = 100;
//创建锁对象
//Object o = new Object(); //不常用、一般用（对象.class）字节码对象
//2.实现接口中未实现的方法，run()中放着的是我们的业务
@Override
public void run() {
//4.通过循环结构完成业务
while (true) {
/*3.同步代码块：synchronized(锁对象){会出现安全隐患的所有代码}
* 同步代码块在同一时刻，同一资源只会被一个线程独享*/
/*这种写法不对，相当于每个线程进来的时候都会new一个锁对象，线程间使用的并不是同一把锁*/
//synchronized (new Object()){
//修改同步代码块的锁对象为成员变量o,因为锁对象必须唯一
synchronized (TicketR3.class) {//同步代码块解决的是重卖的问题
//如果票数>0就卖票
if (tickets > 0) { //解决超卖的问题
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
//4.1打印当前正在售票的线程名以及票数-1
System.out.println(Thread.currentThread().getName() + "=" + tickets--);
}
//4.2退出死循环--没票的时候就结束
if (tickets <= 0) break;
}
}
}
}
注意：线程池负责将线程加入到就绪队列中，但并不代表所有的线程都会运行，线程能否执行还是取决于OS的调用，如果没有被分配时间片，是转换不了运行状态的
注意：线程池是不关闭的，主要就是想实现线程的随取随用，这样就避免了频繁的创建与销毁线程，浪费大量资源，对于我们现在一个javaDemo的练习，大家可以手动关闭当前程序即可。
1 同步锁
前言：
我们遇到了线程安全的相关问题,比如多线程售票情景下的超卖/重卖现象.
我们如何判断程序有没有可能出现线程安全问题,主要有以下三个条件：
在多线程程序中 + 有共享数据 + 多条语句操作共享数据
多线程的场景和共享数据的条件是改变不了的(就像4个窗口一起卖100张票,这个是业务)
所以思路可以从第3点"多条语句操作共享数据"入手,既然是在这多条语句操作数据过程中出现了问题
那我们可以把有可能出现问题的代码都包裹起来，一次只让一个线程来执行
1.1 同步与异步
同步：每次只有一个线程独占资源，排队，效率低但是安全，synchronized也被称作同步关键字异步：是多个线程抢占资源的效果，不排队，效率高，但是数据不安全
1.2 synchronized同步关键字
1.3 写法
synchronized (锁对象.class){
需要同步的代码(也就是可能出现问题的操作共享数据的多条语句);
}为什么同步代码块的锁对象可以是任意的同一个对象,但是同步方法使用的是this呢? 因为同步代码块可以保证同一个时刻只有一个线程进入 但同步方法不可以保证同一时刻只能有一个线程调用,所以使用本类代指对象this来确保同步
2.多线程数据安全隐患解决方案
1. 出现数据安全问题的原因：
多线程程序
多个线程拥有共享数据
多条语句操作共享数据
2. 解决方案：加锁synchronized
同步代码块【常用】，格式：
synchronized（唯一的锁对象）{
可能出现数据安全问题的所有代码
}
同步方法【不常用】，格式：
在方法的定义上加synchronized
3.使用同步时的注意事项：
锁对象必须唯一！！！
比如：如果是实现接口的方式，只创建了一个目标业务类对象(接口实现类对象)，那么也只有一个锁对象
比如2：如果是继承Thread类的方式，你可能要创建多个子类的对象，那这个时候需要给锁对象加static，保证锁对象唯一被所有对象共享
所以：继承的方式，常用的锁对象是类名.class字节码对象
锁对象的类型不做限制，只要能保证唯一即可
加锁的范围需要认真考虑
不能太大，也不能太小，太大浪费效率，太小锁不住
5.多线程售票案例中问题的解决方案：
1.创建4个线程对象，售卖400张票：
解决方案：将票数设置为静态，被全局所有对象共享
2.票数出现了重卖(一张票卖给了多个人)的现象：
解决方案：使用同步代码块，确保一次只有一个线程卖票
3.票数出现了超卖(卖出了超出范围的票0 -1 -2)的现象：
解决方案：优化代码逻辑，有票的时候再卖票，没票的时候就停止，有多种方案，以测试结果为准即可。
扫一扫
366
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
