目录
[2. 引入锁,实现线程安全](#2. 引入锁,实现线程安全)
多线程基础知识要点
案例一:单例模式
是一种设计模式
软件设计需要框架,这是硬性的规定;设计模式是软性的规定。遵循好设计模式,代码的下限就被兜住了
单例 = 单个实例(对象)
某个类在一个进程中只应该创建出一个实例(原则上不应该有多个)
使用单例模式可以对代码进行一个更严格的校验和检查
实现单例模式~
饿汉模式
第1步:
java
class Singleton{
private static Singleton instance = new Singleton();
}
这里的static指的是类属性,而instance就是Singleton类对象持有的属性
每个类的类对象只存在一个,类对象中的static属性自然只有一个了
因此instance指向的这个对象,就是唯一的对象
第2步:
其他代码要想使用这个类的实例就需要通过这个方法来进行获取。不应该在其他代码钟重新new这个对象,而是使用这个方法获取到现成的对象(已经创建好的对象)
第3步:奇淫巧计
这里直接把Singleton给private了,其他代码根本没办法new
此时,无论你创建多少个对象,这些对象其实都是一样的
饿汉模式下,实例是在类加载的时候就创建了,创建时机非常早,相当于程序一启动,实例就创建了。"饿汉"形容"创建实例非常迫切,非常早"
欸!但是用非常规手段:反射就可以打破上述约定。我们可以用枚举方法来创建单例模式
懒汉模式
创建实例的时机更晚,只到第一次使用的时候才会创建实例
"懒"的思想
比如有一个非常大的文件(10GB),有一个编辑器,使用编辑器打开这个文件,如果是按照饿汉的方式,编辑器就要把这10GB先加载到内存里,然后再统一地展示。加载太多数据,用户还得一点点看,没办法一下看那么多
如果按照懒汉的方式,编辑器就会制度取一小部分数据,把这部分数据先展示出来,随着用户翻页之类的操作再继续读后面的数据。这样效率可以提高
java
class SingletonLazy{
private static SingletonLazy instance = null;//先初始化为null,不是立即初始化
public static SingletonLazy getInstance(){
if (instance == null){
instance = new SingletonLazy();//首次调用getInstance才会创建出一个实例
}
return instance;
}
private SingletonLazy(){}
}
思考:懒汉模式是否线程安全?
这样t1 new了一个对象,t2也new了一个对象,就会出现bug
所以,懒汉模式不是线程安全的
那怎么改成线程安全的呢?
1.加锁,synchronized
2.把if和new两个操作打包成一个原子
仍然是t1和t2两个线程,t1先执行加锁代码,t2就被阻塞了,要等待t1释放锁才能继续执行
而t1把instance修改之后,t2的if条件就不成立了,直接就返回了
emm,这段代码还不够完美...
在多线程里面,当第一个线程加了锁,后面的线程再调用getInstance就是纯粹的读操作了,也就不会有线程问题了。那么没有线程的代码每次执行都要加锁和解锁,每次都会产生阻塞,效率巨低!
所以在synchronized外边还得再套一层if,判定代码是否要加锁。仍然将instance是否为空作为判断条件
第一个if判定是否加锁
第二个if判定是否要创建对象
🆗上面的代码还有一点问题
涉及到指令重排序引起的线程安全问题
指令重排序是指调整原有代码的执行顺序,保证逻辑不变的前提下提高程序的效率
为什么调整代码执行顺序可以提高程序效率?
比如我们去超市买东西,我们需要买黄瓜,胡萝卜,西红柿,土豆。我们就有很多种去不同摊位的路径选择,每种选择的最终总购买时间不一样。这就相当于程序的效率。
这行代码可以分成三个大步骤
1.申请一段内存空间
2.在这个内存上调用构造方法,创建出这个实例
3.把这个内存地址赋给Instance引用变量
假设有t1和t2两个线程
t1线程按照1 3 2的执行顺序,就会出现问题
解决上述问题核心思路:volatile
volatile有两个功能:
1)保证内存可见性,每次访问变量必须要重新读取内存,而不会优化到寄存器/缓存中
2)禁止指令重排序,针对这个volatile修饰的变量的读写操作的相关指令,是不能被重排序的
这样修改之后,针对instance变量的读写操作就不会出现重排序
案例二:阻塞队列
特点:1.线程安全;2.阻塞
如果一个已经满了的队列进行入队列,此时入队列操作就会阻塞,一直阻塞到队列不满之后
如果一个已经空的队列进行出队列,出队列操作就会阻塞,一直阻塞到队列有元素为止
可以实现生产者消费者模型
这个模型可以更好地解耦合(把代码的耦合程度从高降低)
实际开发中,往往会用到分布式系统,服务器整个功能不是由一个服务器完成的,而是每个服务器负责一部分功能。通过服务器之间的网络通信,最终完成整个功能
在这个案例中,A和B,C之间的耦合性比较强,一旦B或者C挂了一个,A也就跟着挂了
如果引入生产者消费者模型
这个阻塞队列不是简单的数据结构,而是基于这个数据结构实现的服务器程序,又被部署到单独的主机上
削峰填谷
为啥当请求多了的时候,服务器就容易挂?
因为服务器处理每个请求都是要消耗硬件资源(包括但不限于CPU,内存,硬盘,网络带宽),上述任何一种硬件资源达到瓶颈,服务器都会挂
因为B和C抗压能力比较弱,所以我们可以用一个阻塞队列来承担峰值请求
阻塞队列:数据结构
消息队列:基于阻塞队列实现服务器程序
Java标准库里线程的阻塞队列
BlickingQueue: ArrayBlockingQueue, LinkedBlockingQueue, PriorityBlockingQueue
java
BlockingDeque<String> queue = new ArrayBlockingQueue<>(100);
queue.put("aaa");
put和offer都是入队列,但是put带有阻塞功能,而offer没带阻塞功能,队列满了会返回布尔结果
java
String elem = queue.take();
System.out.println("elem = "+elem);
take用来出队列,带有阻塞功能
接下来我们自己实现一个阻塞队列
1.先实现一个循环队列
java
class MyBlockingQueue{
private String[] elems = null;
private int head = 0;
private int tail = 0;
private int size = 0;
public MyBlockingQueue(int capacity){
elems = new String[capacity];
}
public void put(String elem){
//新的元素放到tail指向的位置上
if (size >= elems.length){
//队列满了,需要下面这个代码阻塞
return;
}
//新的元素要放到tail指向的元素上
elems[tail] = elem;
tail++;
if(tail >= elems.length){
tail = 0;
}
size++;
}
public String take(){
if(size == 0){
//队列空了,需要下面这个代码阻塞
return null;
}
String elem = elems[head];
head ++;
if(head >= elems.length){
head = 0;
}
size--;
return null;
}
}
2. 引入锁,实现线程安全
java
private static Object locker = new Object();
public MyBlockingQueue(int capacity){
elems = new String[capacity];
}
public void put(String elem){
synchronized (locker){
//新的元素放到tail指向的位置上
if (size >= elems.length){
//队列满了,需要下面这个代码阻塞
return;
}
//新的元素要放到tail指向的元素上
elems[tail] = elem;
tail++;
if(tail >= elems.length){
tail = 0;
}
size++;
}
}
public String take(){
String elem = null;
synchronized (locker){
if(size == 0){
//队列空了,需要下面这个代码阻塞
return null;
}
elem = elems[head];
head ++;
if(head >= elems.length){
head = 0;
}
size--;
return elem;
}
}
}
3.实现阻塞
对于满了的情况,用wait方法阻塞,在出队列成功之后再进行唤醒
队列空的情况,在入队列成功后的线程中唤醒
java
public void put(String elem) throws InterruptedException {
synchronized (locker){
//新的元素放到tail指向的位置上
while (size >= elems.length){
//队列满了,需要下面这个代码阻塞
locker.wait();
}
//新的元素要放到tail指向的元素上
elems[tail] = elem;
tail++;
if(tail >= elems.length){
tail = 0;
}
size++;
//入队列成功后唤醒
locker.notify();
}
}
public String take() throws InterruptedException {
String elem = null;
synchronized (locker){
while (size == 0){
//队列空了,需要下面这个代码阻塞
locker.wait();
}
elem = elems[head];
head ++;
if(head >= elems.length){
head = 0;
}
size--;
//出队列成功后唤醒
locker.notify();
}
return elem;
}
这里的if为什么改成while了呢?
因为if只能判定一次条件,有时候一旦程序进入阻塞之后再被唤醒,中间隔的时间会很长,这个间隔过程变数很多,可能这个入队列的条件无法再满足了。
欸那改成while之后,就是wait唤醒之后再判定一次条件,wait之前判定一次,唤醒之后再判定一次(就是多做一次确定)。再次确认发现队列还是满的,那就继续等待。
实现生产者消费者模型
java
public static void main(String[] args) {
MyBlockingQueue queue = new MyBlockingQueue(1000);
//生产者
Thread t1 = new Thread(()->{
int n = 1;
while(true){
try {
queue.put(n + "");
System.out.println("生产元素 " + n);
n++;
Thread.sleep(500);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
});
//消费者
Thread t2 = new Thread(()->{
while(true){
try {
String n = queue.take();
System.out.println("消费元素 " + n);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
});
t1.start();
t2.start();
}
实际开发中,生产者和消费者往往不仅仅是一个线程,也可能是一个独立的服务器程序
案例三:定时器
可以设定一个时间,时间到了的时候,定时器自动执行某个逻辑(比如,写博客定时发布)
用法:定义一个timer添加多个任务,每个任务同时会带有一个时间
Timer里面内置了前台线程,因为timer不知道你的代码是否还会添加新的任务进来,仍然严正以待
需要使用cancel来主动结束
现在我们来手搓一个定时器
需要有什么?1.一个可以帮我们掐时间的线程 ;2.一个能帮我们存储任务的优先级队列
因为每个任务都带有delay时间的,用优先级队列可以先执行时间小的,后执行时间大的
扫描线程就不必遍历了,只需要关注队首元素是否到时间(队首没到时间,其他元素也没到时间)
计时任务
任务优先级逻辑(时间小的优先级越高)
计时器
问题
线程安全
由于我们在主线程中对队列的元素进行添加,而扫描线程对已完成的元素进行删除,两个线程操作同一个优先级队列变量,会有线程安全问题
此时需要加锁来解决线程安全问题
schedule方法(主线程要调用)的加锁
判断:以下哪种加锁方法是正确的
java
//第一种
public MyTimer(){
t = new Thread(()->{
//扫描线程就需要循环的反复扫描队首元素,然后判定队首任务时间是否到达
//时间到了就执行任务并删除这个任务
//时间没到就啥都不干
synchronized (locker){
while (true){
if (queue.isEmpty()){
continue;
}
MyTimerTask task = queue.peek();
//获取当前时间
long curTime = System.currentTimeMillis();
if(curTime >= task.getTime()){
//当前时间已经到了任务时间,就可以执行任务了
queue.poll();
task.run();
}else{
//时间还没到,暂时先不执行
continue;
}
}
}
});
//第二种
public MyTimer(){
t = new Thread(()->{
//扫描线程就需要循环的反复扫描队首元素,然后判定队首任务时间是否到达
//时间到了就执行任务并删除这个任务
//时间没到就啥都不干
while (true){
synchronized (locker){
if (queue.isEmpty()){
continue;
}
MyTimerTask task = queue.peek();
//获取当前时间
long curTime = System.currentTimeMillis();
if(curTime >= task.getTime()){
//当前时间已经到了任务时间,就可以执行任务了
queue.poll();
task.run();
}else{
//时间还没到,暂时先不执行
continue;
}
}
}
});
}
第一种方法,把锁放到while外面,如果while没有结束的话,锁永远都释放不了,主线程调用schedule方法就永远上不了锁。所以我们要采用第二种方法,把锁加到while里面,才有释放锁的机会
线程饿死
上面的第二种方法虽然解决了线程安全问题,但是这部分代码执行速度很快,解锁之后就立即重新加锁,导致其他线程想通过schedule加锁都加不上,所以我们需要使用wait来解决
一旦由新的任务加入,wait就会被唤醒,因为不知道加入的任务是不是最早的任务,所以我们用task.getTime() - curTime来获取任务时间
没有新的任务,时间到了。按照原定计划,执行之前的这个最早的任务即可
执行结果
理解代码过程
理解peek:
⚠
优先级队列:无论添加多少元素,这里的peek都是得到时间最小的值。
理解run方法
👇
👇
👇(Runnable作为描述任务的主体)
👇
main方法里面写出任务具体执行代码
案例四:线程池
池是什么?
池就相当于一个共享资源,是对资源的整合和调配,节省存储空间,当需要的时候可以直接在池中取,用完之后再还回去。比如,如果你喝水,你可以拿杯子去水龙头接。如果很多人喝水,那就只能排队去接。
Java常用的池有常量池,数据库连接池,线程池,进程池,内存池
最开始进程能够解决并发编程的问题,但是因为频繁创建销毁进程的成本太高了,引入了线程这种轻量级进程。但是如果创建销毁线程的频率进一步提高,这里的开销也不能忽视
那怎么优化线程创建销毁效率呢?
1.引入轻量级线程--纤程/协程
协程本质是程序员在用户态代码中进行调度,不是靠内核的调度器来调度的
协程运行在线程之上,当一个协程执行完成后,可以选择主动让出,让另一个协程运行在当前线程之上。可以节省很多调度上的开销。
⚠线程里有协程这句话是**不严谨的,**因为协程本身不是系统级别的概念,是用户代码中基于线程封装出来的,有不同的实现方法,可能n个协程对应1个线程,也可能n个协程对应m个线程
**2.引入线程池。**把要使用的线程提前创建好,用完了也不要直接释放而是备下次使用,就节省创建/销毁线程的开销
从线程池里取线程(纯用户态代码)比从系统申请更高效!
比如一个事情一个人自己就能完成,就更可控,更高效,这种相当于纯用户态代码
但是如果这个事情这个人要拜托其他人来完成,不知道委托人要花多少时间,就不可控,更低效。相当于去系统申请线程
标准库中的线程池:ThreadPoolExecutor
构造方法(面试题常考)
标准库提供的线程池,持有的线程个数并不是一成不变的,会根据当前的任务量自适应线程个数
核心线程数(规定一个线程池里最少有多少个线程)
最大线程数(规定一个线程最大有多少个线程)
某个线程超过保持存活时间阈值就会被销毁掉
和定时器类似,线程池中可以持有多个任务
-- 线程工厂
通过这个工厂类创建线程对象(Thread对象),在这个类里面提供了方法,让方法封装new Thread的操作,同时给Thread设置一些属性
设计模式:工厂模式。通过专门的工厂类/对象来创建指定的对象
例子:
java//平面上的一个点 class Point{ public Point(double x, double y){...}//通过笛卡尔坐标构造这个点 //还可以用三角函数转换笛卡尔坐标 //x = r * cos(a); y = r * sin(a) public Point(double r, double a){...}//通过极坐标系来构造点(半径,角度) }
上面代码能编译通过吗?不能。因为不能构成重载(因为形参类型和个数相同了)
为了让上面代码通过,就可以引入工厂模式
javaclass Point{ //工厂方法 public static Point makePointByXY(double x, double y){ Point p = new Point(); p.setX(x); p.setY(y); return p; } public static Point makePointByRA(double r, double a){ Point p = new Point(); p.setR(r); p.setA(a); return p; } Point p = Point.makePointByXY(x, y); Point p = Point.makePointByRA(r, a); }
通过静态方法封装new操作,在方法内部设定不同的属性完成对象初始化,这个构造对象的过程就是工厂模式
拒绝策略
在线程池中,有一个阻塞队列,能够容纳的元素有上限,当任务队列已经满了,如果继续往队列中添加任务,线程池中就会拒绝添加
四种拒绝策略
第一种:继续添加任务,直接抛出异常
第二种:新的任务由添加任务的线程负责执行(线程池不会执行)--谁揽的活谁干
第三种:丢弃最老的任务
第四种:丢弃最新的任务
Executors工厂类
通过这个类创建不同的线程池对象
例子
java
public static void main(String[] args) {
ExecutorService service = Executors.newFixedThreadPool(4);
service.submit(new Runnable() {
@Override
public void run() {
}
});
}
啥时候使用Executors,啥时候使用ThreadPoolExecutor
Executors方便只是简单用一下,ThreadPoolExecutor希望高度定制化
线程池里最好有多少个线程?(具体情况具体分析,回答具体数字就是错误的)
线程里的任务分成两种
CPU密集型任务:这个线程大部分时间都在CPU上运行/计算。比如在线程run里面计算1+2+3+...+10w。
IO密集型任务:这个线程大部分时间都在等待IO,不需要去CPU上运行。比如线程run里加scanner,读取用户输入。
如果一个进程中,所有的线程都是CPU密集型,每个线程所有的工作都在CPU上执行。此时,线程数目就不应该超过N(CPU逻辑核心数)。------每个线程都要占一个核,超过N就失控了
如果一个进程中,所有的线程都是IO密集型,每个线程大部分工作都在等待IO,CPU消耗非常少。此时线程数目就可以很多,远远超过N。------一个线程工作,其他线程休息,不霸占CPU核
手敲线程池
1.提供构造方法,指定创建多少个线程
2.在构造方法中,把这些线程都创建好
3.有一个阻塞队列,能够持有要执行的任务
4.提供submit方法,能够添加新的任务
写的过程中遇到问题
run变量捕获到i之后,正常情况i是不能变的,但是i因为循环造成改变,引发编译器异常
此处的n就是一个实时final变量,每次循环就创建一个不可变的n,这个n是可以被捕获的
java
package Thread;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
class MyThreadPoolExecutor{
private List<Thread> threadList = new ArrayList<>();
//创建一个用来保存任务的队列
private BlockingQueue<Runnable> queue = new ArrayBlockingQueue<>(1000);
//通过n指定创建多少个线程
public MyThreadPoolExecutor(int n){
for (int i = 0; i < n; i++) {
Thread t = new Thread(()->{
while (true) {
try {
//此处take带有阻塞功能,如果此处队列为空,take就会阻塞
Runnable runnable = queue.take();
//取出一个任务就执行一个任务
runnable.run();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
t.start();
threadList.add(t);
}
}
public void submit(Runnable runnable) throws InterruptedException{
queue.put(runnable);
}
}
public class ThreadDemo11 {
public static void main(String[] args) throws InterruptedException{
MyThreadPoolExecutor executor = new MyThreadPoolExecutor(4);
for (int i = 0; i < 1000; i++) {
int n = i;
executor.submit(new Runnable() {
@Override
public void run() {
System.out.println("执行任务 "+ n + ", 当前线程为:" + Thread.currentThread().getName());
}
});
}
}
}
更体现多线程执行顺序不确定