目录
两个设计模式: 单例模式, 工厂模式
单例模式
有些场景中希望有些类仅仅创建一个对象, 代码中很多管理数据的对象都是单例的, MySQL JDBC等.
人可能会出错, 需要编译器帮我们做出监督. 就比如 @Override 必须是方法重写.,在语法层面上没有对单例做出支持, 只能通过编程技巧实现
饿汉模式
刚开始就创建了实例举个例子:
//期望这个类能有唯一实例
class Singleton {
//设置为静态变量在 Singleton 类被加载时会创建实例
private static Singleton instance = new Singleton();
//获取实例
public static Singleton getInstance() {
return instance;
}
//把构造方法设为 私有 , 类外面的代码无法 new 出类对象了.
private Singleton() {};
}注意:
1> 在类的内部提供线程的实例
2> 把构造方法设为 private ,避免其他代码创建实例.
懒汉模式
先判断是否需要创建实例举个例子:
//期望这个类能有唯一实例
class SingletonLazy {
private static volatile SingletonLazy instance = null;
//获取实例
public static SingletonLazy getInstance() {
if(instance == null) {
synchronized (SingletonLazy.class) {
if(instance == null) {
instance = new SingletonLazy();
}
}
}
return instance;
}
//把构造方法设为 私有 , 类外面的代码无法 new 出类对象了.
private SingletonLazy() {};
}注意:
1> 第一次判断是否为空原因:
因为加锁开销很大, 而且可能涉及到锁冲突, 所以我们增加一次判断, 不为空直接返回 instance
2> 加锁的原因:
在本操作中会出现读取和修改的操作, 会出现两个都判断为空后创建多个实例的情况.
3> 使用 volatile 原因:
指令重排序问题
编译器为了提高效率, 可能调整代码的执行顺序, 但是必须保持代码逻辑不变, 单线程没问题, 但是多线程可能有问题.
new 操作, 可能触发指令重排序
new 操作分为三步:
1. 申请内存空间
2. 在内存空间上构造对象
3. 把内存地址给 instance
可能按照 123, 132顺序执行, 1一定先执行
在多线程下, 假设 t1线程 按照1 3 2 的顺序 执行1 3后, instance非空指向一个没初始化的非法对象, 这时 t2线程 在判断instance 不为空后, 直接返回一个非法对象, 导致出现bug
使用 volatile 保证不会出现指令重排序问题
阻塞队列
多线程代码中比较常用到的一种数据结构
特殊的队列
1> 线程安全
2> 带有阻塞特性
a) 如果队列为空, 继续出队列, 就会发生阻塞, 阻塞到其他线程往队列里添加元素位置为止
b) 如果队列为满, 继续入队列, 也会发生阻塞, 阻塞到其他线程从队列中取走元素位置为止.
意义: 实现 " 生产者消费者模型 " 一种常见的多线程代码编写方式
举个例子: 包饺子
1> 每个人分别负责擀饺子皮和包饺子
2> 当擀饺子皮快了 就会在 放饺子皮的盖帘满的时候停下来等包饺子的
3> 当包饺子快了 就会停下来等 擀饺子皮的
盖帘就相当于阻塞队列
生产者 把生产出来的内容放到阻塞队列中
消费者 从阻塞队列中获取元素
生产者消费者模型意义:
1> 解耦合
两个模块联系越紧密, 耦合就越高, 这个模型让耦合降低
2> 削峰填谷
服务器 A 给服务器 B发起请求, 不同服务器消耗的硬件资源不一样, A收到的请求发给B可能就挂了.使用削峰填谷让 B 接受的请求按照 B 的原有节奏处理情况.(这种情况一般不会持续存在, 就好比学校抢课的情况), 峰值过后 Ｂ把积压的数据处理掉
阻塞队列使用方法
在 Java 标准库里, 已经提供了现成的 阻塞队列直接使用
在标准库里, 针对 BlockingQueue 提供了两种最重要的实现方式
1> 基于数组
2> 基于链表
BlockingQueue 一般不适用 Queue 中的一些方法, 因为他们不具备阻塞的特性.
一般使用 (put 阻塞式的入队列), (take 阻塞式的出队列)
示例:
public class Test {
public static void main(String[] args) throws InterruptedException {
BlockingDeque<String> queue = new LinkedBlockingDeque<>();
queue.put("111");
queue.put("222");
queue.put("333");
queue.put("444");
String elem = queue.take();
System.out.println(elem);
elem = queue.take();
System.out.println(elem);
elem = queue.take();
System.out.println(elem);
elem = queue.take();
System.out.println(elem);
elem = queue.take();
System.out.println(elem);
}
}
最后一次输出时发生了阻塞.
实现阻塞队列
基于普通队列加上阻塞和线程安全
普通队列基于数组 或者 基于链表
基于数组实现队列理解成一个环
class MyBlockingQueue {
private String[] data = new String[1000];
// 队列的起始位置
private int head = 0;
// 队列的结束位置的下一个位置
private int tail = 0;
//队列中有效元素的个数
private int size = 0;
//提供的方法 入队列 出队列
public void put(String elem) throws InterruptedException {
synchronized (this) {
while(size == data.length) {
this.wait();
}
data[size] = elem;
tail++;
if(tail == data.length) {
tail = 0;
}
size++;
//这个 notify 用来唤醒 take 中的 wait
this.notify();
}
}
public String take() throws InterruptedException {
synchronized (this) {
while(size == 0) {
this.wait();
}
String ret = data[head];
head++;
if(head == data.length) {
head = 0;
}
size--;
//这个 notify 用来唤醒 put 中的 wait
this.notify();
return ret;
}
}
}wait 除了可以用 notify 唤醒, 还可以用 interrupt 唤醒, 直接整个方法结束了, 因为使用了 throws 抛出异常, 这是没有什么事
如果使用 try catch 方式就会出现bug, 让 tail 把指向的元素覆盖掉了, 然后弄丢了一个元素, 而且 size 也会比数组最长长度还大.(此处不理解看http://t.csdnimg.cn/OBwXN -->中断一个线程目录)
所以在wait 返回的时候进一步确认是否当前队列是满的不是, 如果是满的继续进行wait
所以直接使用 while 判定是否是满的.
为了避免内存可见性问题, 把 volatile 加好
阻塞队列实现生产者消费者模型
package Demo2;
import java.util.concurrent.BlockingDeque;
import java.util.concurrent.LinkedBlockingDeque;
class MyBlockingQueue {
private String[] data = new String[1000];
// 队列的起始位置
private volatile int head = 0;
// 队列的结束位置的下一个位置
private volatile int tail = 0;
//队列中有效元素的个数
private volatile int size = 0;
//提供的方法 入队列 出队列
public void put(String elem) throws InterruptedException {
synchronized (this) {
while(size == data.length) {
this.wait();
}
data[tail] = elem;
tail++;
if(tail == data.length) {
tail = 0;
}
size++;
//这个 notify 用来唤醒 take 中的 wait
this.notify();
}
}
public String take() throws InterruptedException {
synchronized (this) {
while(size == 0) {
this.wait();
}
String ret = data[head];
head++;
if(head == data.length) {
head = 0;
}
size--;
//这个 notify 用来唤醒 put 中的 wait
this.notify();
return ret;
}
}
}
public class Test {
public static void main(String[] args) {
MyBlockingQueue queue = new MyBlockingQueue();
// 消费者
Thread t1 = new Thread(() -> {
while(true) {
try {
String result = queue.take();
System.out.println("消费元素: " + result);
Thread.sleep(500);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
});
// 生产者
Thread t2 = new Thread(() -> {
int num = 1;
while(true) {
try {
queue.put(num+ " ");
System.out.println("生产元素: " + num);
num++;
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
});
t1.start();
t2.start();
}
}
定时器
约定一个时间, 时间到达之后执行某个代码逻辑, 在网络通信中很常见
在 标准库 中有现成定时器的实现
public static void main(String[] args) {
Timer timer = new Timer();
// 给定时器安排了一个任务, 预定在 xxx 时间去执行
timer.schedule(new TimerTask() {
@Override
public void run() {
System.out.println("执行定时器任务");
}
}, 2000);
System.out.println("程序启动!");
}使用匿名内部类的写法继承 TimerTask 创建出实例, 目的时重写 run, 描述任务的详细情况
当前代码也是多线程, timer 里面包含一个线程, 下图是运行结果
可以发现整个进程没有结束, 因为 Timer 内部的线程阻止了进程结束.
Timer 里面可以安排多个任务.
public static void main(String[] args) {
Timer timer = new Timer();
// 给定时器安排了一个任务, 预定在 xxx 时间去执行
timer.schedule(new TimerTask() {
@Override
public void run() {
System.out.println("3000");
}
}, 3000);
System.out.println("程序启动!");
timer.schedule(new TimerTask() {
@Override
public void run() {
System.out.println("2000");
}
}, 2000);
System.out.println("程序启动!");
timer.schedule(new TimerTask() {
@Override
public void run() {
System.out.println("1000");
}
}, 2000);
System.out.println("程序启动!");
}
实现简单的定时器
1> Timer 中需要有一个线程, 扫描任务是否到时间了, 可以执行了
2> 需要一个数据结构把所有任务保存起来(使用优先级队列)
3> 创建一个类, 通过类的对象描述一个任务(至少要包含任务内容和时间)
其中需要记录, 绝对的时间.
import java.awt.*;
import java.util.PriorityQueue;
import java.util.Timer;
import java.util.TimerTask;
// 通过这个类, 描述一个任务
class MyTimerTask implements Comparable<MyTimerTask> {
// 执行的任务
private Runnable runnable;
// 执行任务的时间
private long time;
// 此处的 delay 就是 schedule 方法传入的 "相对时间"
public MyTimerTask(Runnable runnable, long delay) {
this.runnable = runnable;
this.time = System.currentTimeMillis() + delay;
}
@Override
public int compareTo(MyTimerTask o) {
// 让队首元素是最小时间的值
return (int) (this.time - o.time);
// 让队首元素是最大时间的值
//return (int) (o.time - this.time);
}
public long getTime() {
return time;
}
public Runnable getRunnable() {
return runnable;
}
}
// 自己的定时器
// 添加元素和扫描线程是不同线程操作同一个队列, 需要加锁 <--原因之一
class MyTimer {
// 使用一个数据结构, 保存所有的任务
private PriorityQueue<MyTimerTask> queue = new PriorityQueue<>();
// 使用这个对象作为锁对象
private Object locker = new Object();
public void schedule(Runnable runnable, long delay) {
synchronized(locker) {
queue.offer(new MyTimerTask(runnable, delay));
locker.notify();
}
}
// 扫描线程
public MyTimer() {
// 创建一个扫描线程
Thread t = new Thread(() -> {
// 扫描线程需要不停扫描看是否到达时间
while (true) {
try {
synchronized (locker) {
// 不要使用 if 作为 wait 的判定条件, 应使用while
// 使用 while 是为了在唤醒之后 在再次确认一下条件
while (queue.isEmpty()) {
locker.wait();
}
MyTimerTask task = queue.peek();
// 比较一下当前的队首元素是否可以执行了
long curTime = System.currentTimeMillis();
if (curTime >= task.getTime()) {
// 执行任务
task.getRunnable().run();
//执行完了, 就从队列中删除
queue.poll();
} else {
// 不可执行, 先等着, 等待下一轮的循环判定
locker.wait(task.getTime() - curTime);
}
}
}catch (InterruptedException e) {
e.printStackTrace();
}
}
});
t.start();
}
}
public class Demo2 {
public static void main(String[] args) {
MyTimer timer = new MyTimer();
timer.schedule(new Runnable() {
@Override
public void run() {
System.out.println("3000");
}
}, 3000);
timer.schedule(new Runnable() {
@Override
public void run() {
System.out.println("2000");
}
}, 2000);
timer.schedule(new Runnable() {
@Override
public void run() {
System.out.println("1000");
}
}, 1000);
}
}工厂模式
线程池
线程创建/销毁 比 进程快, 但是进一步提高创建/销毁的频率, 线程的开销也不能忽视了
两种提高效率的方法:
1> 协程 (轻量级线程)
相对于线程, 把系统调度的过程给忽略了,(程序猿手动调度), 当下比较流行(Java 标准库没有协程)
2> 线程池
兜底, 使线程不至于很慢
例子: 我是个妹子, 在谈男朋友, 一段时间后, 我不想和他好了, 就冷暴力然后分手, 分手之后再去找另一个小哥哥, 然后和另一个小哥哥好上了.
线程池就是我在谈第一个男朋友的时候就同时和其他小哥哥搞暧昧(培养感情), 哪天想分手了直接分, 然后无缝衔接
线程池: 在使用第一个线程的时候, 提前把 2, 3, 4, 5线程创建好(培养感情), 后续想使用新的线程不必创建, 直接使用(创建线程的开销降低了)
为啥呢? 从池子里面取 比 创建线程 效率更高
从池子里取, 就是纯粹用户态操作
创建新的线程需要 用户态 + 内核态 相互配合 完成
操作系统是由 内核 + 配套的应用程序 构成
内核 是系统最核心的部分, 创建线程操作需要调用系统 api, 进入到内核中, 按照内核态的方式来完成一系列动作
当你想要创建线程的时候, 内核需要给所有进程提供服务, 不可控, 难以避免会做一些其他的事导致效率减低
线程池的创建
Java标准库提供了写好的线程池.
创建线程池对象并没有 new , 而是通过专门的方法返回了一个线程池对象(工厂模式), 通常创建对象使用 new , new 就会触发类的构造方法, 但构造方法存在一定的局限性. 工厂模式是给构造方法填坑的.
怎么填坑
我们构造一个对象希望有多种构造方式, 这就需要多个构造方法, 但是构造方法的名字必须是类名, 不同的构造方法只能通过 重载区分, 但是如果实现方法不一样, 但是参数类型/个数一样咋办呢?
使用工厂设计模式, 使用普通的方法代替构造方法完成初始化工作, 普通方法使用名字区分.
Executors 是一个 工厂类, newCachedThreadPool 是工厂方法, 使用静态方法通过类名调用
工厂方法有很多, 上述方法创建出来的线程池对象的线程数目可以动态适应, 随着王线程池里面添加任务, 线程池中的线程自动创建, 创建出来在池子里保留一定时间以备后续使用.
这个方法是固定的线程池, 调用方法时手动指定创建几个线程
还用很多其他线程池上面介绍的两种用的更多一点
ThreadPoolExecutor
上述工厂方法生成的线程池本质上是对 类(ThreadPoolExecutor) 的封装
核心方法:
1> 添加任务
2> 构造
举例: 1> 添加任务 (简单)
使用 submit 把任务交给线程池
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Demo3 {
public static void main(String[] args) {
ExecutorService service = Executors.newFixedThreadPool(4);
service.submit(new Runnable() {
@Override
public void run() {
System.out.println("hello");
}
});
}
}2> 构造方法 (重点)
构造方法中参数很多[经典面试题]
在 juc 包里面, 并发编程相关内容
全部参数 如下图:
对这 4 种情况 举个例子:
我有 任务 A 要做, 朋友来让我帮忙做任务 B, 这时我有 4 种回应方法.
1> 我心态崩了, 大哭. 抛出异常
2> 我对朋友说你自己做, 朋友自己做任务 B
3> 我的任务 A 不做了, 就去帮朋友
4> 我直接拒绝帮忙, 我仍然做任务 A , 朋友也不做任务 B 了
线程数目设置
使用线程池需要设置线程的数目, 设置多少合适?
具体数目是不对的, 需要实际情况分析
原因:
一个线程执行代码主要有两类:
1> cpu 密集型: 代码主要是进行 算术运算/逻辑判断
2> IO密集型: 代码里主要进行的是 IO 操作
如果是 1> 这个时候线程池的数量不要超过 N (设 N 就是极限), 比 N 更大, 就无法提高效率了, cpu吃满了, 线程越多反而增加调度的开销
如果是 2> 不吃 CPU, 此时设置的线程数可以超过 N, 一个核心可以通过调度的方式来并发执行.
实现线程池
class MyThreaPool {
// 任务队列
private BlockingDeque<Runnable> queue = new ArrayBlockingQueue<>();
// 通过这个方法, 把任务添加到队列中
public void submit(Runnable runnable) throws InterruptedException {
//此处策略是第 5 种, 拒绝策略, 阻塞等待
queue.offer(runnable);
}
public MyThreaPool(int n) {
// 创建出 n 个线程, 负责执行上述队列中的任务
for (int i = 0; i < n; i++) {
Thread t = new Thread(() -> {
// 让这个线程从队列中消费任务,并进行执行
try {
Runnable runnable = queue.take();
runnable.run();
} catch (InterruptedException e) {
e.printStackTrace();
}
});
t.start();
}
}
}
小结
认真学习各种多线程代码实例, 理解其中的含义, 将各个代码的的易错点分析透彻
991
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
