一、单例模式
单例模式是一种设计模式，针对一些特定的场景，研究出对应的解决方案，。有些对象在代码中只应该有一个实例，单例模式就是强制某个类只能有一个实例。
单例模式的实现，主要依托于static关键字（被static 修饰的成员，静态成员，把当前的成员变成类属性而不是实例属性~）每个类对象只有一份
单例模式实现有两种，饿汉模式和懒汉模式
饿汉模式
饿汉模式实现：实例创建出现在“类加载”阶段（第一次使用到这个类的时候，就会把这个类.class加载到内存里），线程安全
public class TestSinger {
//实现单例模式
static class Singleton{
//创建一个成员，保存唯一的一个Singleton实例
private static Singleton instance=new Singleton();
//提供方法获取实例
public static Singleton getInstance(){
return instance;
}
private Singleton(){
}
}
public static void main(String[] args) {
//获取到一个实例 ，只能通过 getInstance 无法通过new 的方式来创建新的Singleton
Singleton s=Singleton.getInstance();
}
}
懒汉模式
第一次调用getInstance 方法创建实例 （线程不安全）
public class TestSingleton {
//懒汉模式
//创建实例的时机是第一次调用时创建，比饿汉模式更迟
static class Singleton{
private static Singleton instance=null;
public static Singleton getInstance(){
if(instance==null){
instance=new Singleton();
}
return instance;
}
private Singleton(){
}
}
public static void main(String[] args) {
Singleton s=new Singleton();
}
}
一般来说懒汉模式更好（但不绝对），懒汉模式更高效，但是饿汉模式是线程安全的，懒汉模式是存在线程不安全的状况，因为懒汉模式有创建线程实例操作，此操作不是原子性，
public static Singleton getInstance(){
if(instance==null){
instance=new Singleton();
}
return instance;
}
懒汉模式这里操作先进行读操作（LOAD）,之后进行比较CMP 之后NEW SAVE（写入内存），如果这里有两个线程执行，会发生抢占式,因为这里操作不是原子性的，所有会发生创建多个实例的情况，出现了BUG，
这里我们通过加锁操作来使得操作变为原子性，使得懒汉模式变为线程安全的，可以把锁加到方法上，这时候是针对CMP,NEW 和 SAVE 操作都进行了加锁，三个操作都是串行的，但是这种效率太低了，我们应该把锁作用范围更小一点，针对CMP（判断）和NEW 操作进行加锁，SAVE 只是读操作，并没有修改，不需要加锁，提高效率。
public static Singleton getInstance(){
synchronized (Singleton.class){
if(instance==null){
instance=new Singleton();
}
}
return instance;
}
但是这样的代码，符出的代价太大了，因为每次调用都会进行加锁，我们只是需要instance未初始化之前，才涉及到线程安全问题，后续已经初始化了，就每次要每次都执行加锁，而是只是进行判断就好了，所以又修改了代码，改为双if判断
public static Singleton getInstance(){
if(instance==null){
synchronized (Singleton.class){
if(instance==null){
instance=new Singleton();
}
}
}
return instance;
}
但是这样写还是会有瑕疵，因为在多线程的情况下，可能多个线程进行读操作，由于编译器优化，可能在寄存器读取，而这时候执行操作还没有执行完，还是null的状态，所以我们也要在获取实例时候加上锁
懒汉模式
保证线程安全：
1.加锁，把if判断和new操作加锁
2.双重if循环
3.volatile 关键字
//懒汉模式
static class Singleton{
volatile private static Singleton instance=null;
public static Singleton getInstance(){
if(instance==null){
synchronized (Singleton.class){
if(instance==null){
instance=new Singleton();
}
}
}
return instance;
}
private Singleton(){
}
}
public static void main(String[] args) {
Singleton s=new Singleton();
}
针对单例模式的线程安全要点：
1）加锁（在合适的位置加锁，CMP（判断）和NEW（创建）时加锁，同时加锁的范围也不能太大，避免降低效率）
2）双重 判断（保证需要加锁时候才加锁，一旦初始化完毕了，就不用创建实例，都为读操作，就没必要加锁了）
3）volatile 保证外层 if 读操作，读到的数值都是最新的，不会出现一个正在创建实例，而读取时是NULL 进入IF判断的情况
二、堵塞队列
堵塞队列是什么？ 一种线程安全的队列，
1.首先堵塞队列是线程安全的（内部实现了加锁控制），
2.当队列满的时候，此时就会堵塞，一直到堵塞队列不满的情况下才会完成插入，当队列为空时，从队列中取元素时，也会发生堵塞。
堵塞队列的作用：
帮助我们完成“生产者消费者模型”，作用于服务器开发
生产者和消费者模型通过某种交易场所（某数据结构）来进行交互 ，堵塞队列就是其中的一种数据结构，能够很好的协调生产者和消费者之间的关系，
实际案例（服务器请求）：
一个服务器，同一时刻可能收到很多请求，但是服务器处理能力是有限的，如果同一时间服务器收到的请求太多了，服务器可能就挂了…，针对这样的场景，使用生产者和消费者模式来进行“削峰”，削弱请求峰值对服务器的冲击力，如果服务器面对请求太多了，实际上先把请求放入堵塞队列中，应用程序按照固定的结构从堵塞队列中取出，这些请求冲击的是堵塞队列本身，请求在这里耗着，不会消耗太多的CPU资源，缓解服务器压力
消息队列，是堵塞队列的上级
1.消息队列中数据是有类型的（topic），按照topic进行分类，把相同topic的数据放到不同的队伍中，分别进行排队，一个消息队列，可以支撑多个业务的多组数据~~
2.消息队列往往是单独的服务器/服务器集群，通过网络通信的方式，进行生产者和消费者模型
3.还支持持久化存储（数据存储在磁盘上）
4.消费的时候支持多种消费模式
a)指定位置消费（不一定只是取出队首元素）
b)镜像模式消费（一个数据可以被取多次，不是取一次直接删除）
实现堵塞队列：
public static void main(String[] args) {
//BlockingDeque 本身是一个interface 不能去new
BlockingDeque<String> blockingDeque=new LinkedBlockingDeque<>();
try {
//put 和 take 都有堵塞功能
//堵塞队列也有普通方法但是没有堵塞功能。
blockingDeque.put("hello");
String elem=blockingDeque.take();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
实现一个生产者和消费者模型
import java.util.concurrent.BlockingDeque;
import java.util.concurrent.LinkedBlockingDeque;
public class Demo2 {
//实现生产者和消费者模型
public static void main(String[] args) {
BlockingDeque<String> queue=new LinkedBlockingDeque();
//创建生产者线程
Thread producer=new Thread(){
@Override
public void run() {
for(int i=0;i<10000;i++){
try {
System.out.println("producer 生成 str"+i);
queue.put("str "+i);
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
producer.start();
//消费者线程
Thread customer=new Thread(){
@Override
public void run() {
while(true){
try {
String elem=queue.take();
System.out.println("customer 获取到" + elem);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
customer.start();
try {
producer.join();
customer.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
这里实现的是生产者每一秒生成一个，生产者比消费者慢
可以借助堵塞队列的最大长度来设置一个生产者比消费者快的情况，将最大长度设为10，使用sleep 一秒消费一个，但是一直在生产，这样就是生产者大于消费者，主要使用put（）和take（）方法来操作堵塞队列
实现BlockingQueue
1）首先要实现一个队列，可以用链表或者数组实现队列，这里使用数组实现一个队列（环形队列），定义两个变量head,tail来标记数组头部和尾部，插入元素时，插在tail位置，tail++,出队列时取出head位置元素，head++，定义一个变量来标记长度，如果长度等于数组长度，则要回到数组的头部，来实现环形数组
public class ThreadDemo1 {
//自己实现堵塞队列，先通过数组实现普通队列
static class BlockingQueue{
private int[] array=new int[1000];
private int head=0;//记录头部
private int tail=0;//记录尾部
private int size=0;
//实现入队列
public void put(int value){
if(size==array.length){
System.out.println("队列满了，不能插入");
return ;
}
array[tail]=value;
tail++;
//解决环形数组
if(tail>=array.length){
tail=0;
}
size++;
}
//实现出队列
public Integer take(){
if(size==0){
return null;
}
int ret=array[head];
head++;
if(head>=array.length){
head=0;
}
size--;
return ret;
}
}
}
2.为了保证线程安全给队列进行加锁操作，并且实现堵塞队列
注意实现堵塞队列，此时队列是满的，多个线程实现都是要等待，当一个线程取走一个元素，就会通知其他线程队列不满，多个线程就要竞争锁，所以获取到锁操作后，还是要判断队列是否满，可能这个线程没有竞争到锁，所以要用while()来进行等待
static class BlockingQueue{
private int[] array=new int[1000];
private int head=0;//记录头部
private int tail=0;//记录尾部
//记录队列中元素长度
private int size=0;
//引入一个锁对象
private Object locker=new Object();
//实现入队列
public void put(int value) throws InterruptedException {
synchronized (locker){
while(size==array.length){
locker.wait();
}
array[tail]=value;
tail++;
//解决环形数组
if(tail>=array.length){
tail=0;
}
size++;
locker.notifyAll();
}
}
//实现出队列
public Integer take() throws InterruptedException {
int ret=0;
synchronized (locker){
while (size==0){
locker.wait();
}
ret=array[head];
head++;
if(head>=array.length){
head=0;
}
size--;
locker.notifyAll();//唤醒操作，提醒等待元素，队列有位置了
}
return ret;
}
}
创建一个生产者消费者模型来检验自己实现的堵塞队列是否成功
public static void main(String[] args) throws InterruptedException {
BlockingQueue queue=new BlockingQueue();
Thread producer=new Thread(){
@Override
public void run() {
for(int i=0;i<10000;i++){
try {
System.out.println("生产了元素："+ i);
queue.put(i);
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
producer.start();
Thread customer=new Thread(){
@Override
public void run() {
try {
while(true){
int ret=queue.take();
System.out.println("消费了元素 "+ ret);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
customer.start();
producer.join();
customer.join();
}
实现了一个简单的堵塞队列
三、定时器
定时器就是闹钟，给定时器设定一个任务，约定某个任务XXX时间后执行
目的：让某个任务在某个时间点执行，不是立刻执行
使用Timer 提供的核心接口 schedule 指定一个任务交给定时器，再一定的时间之后执行这个任务
实现定时器
1）Timer 类中要包含一个Task类，每个Task类就表示一个具体的任务，Task里面包含一个时间戳（啥时候执行这个任务），还包含了一个Runnable 实例（用来表示具体任务是啥）
2）Timer里面通过一个带优先级的堵塞队列，来组织若干个task，根据时间先后来排优先级，快带时间的任务优先级更高
3）Timer 中还需要一个专门的线程，让这个线程不停扫描队首元素，看看队首元素是不是可以执行了，如果可以执行了，就执行这个任务，如果不能执行，就继续在队列中等待。
实现定时器:
import java.util.concurrent.PriorityBlockingQueue;
public class ThreadDemo2 {
//实现一个简单的定时器 task要放到一个优先队列中，但是优先队列中需要进行比较排序
static class Task implements Comparable<Task>{
//啥时候去执行
private long time;
//执行什么
private Runnable command;
//一般去设定定时器的时候，传入的时间，一般都是时间间隔
public Task(Runnable command,long time){
this.command=command;
//记录绝对时间
this.time=System.currentTimeMillis()+time;
}
public void run(){
command.run();
}
@Override
public int compareTo(Task o) {
//时间较小的排在前面
return (int)(this.time-o.time);
}
}
static class Timer{
//创建一个带优先级的堵塞队列
private PriorityBlockingQueue<Task> queue=new PriorityBlockingQueue<>();
//使用这个对象来实现线程之间的协调任务
private Object mailBox=new Object();
//schedule 方法的功能就是把一个Task 放到Timer中
public void schedule(Runnable command,long after){
Task task=new Task(command,after);
queue.put(task);
//当worker 线程中包含wait 机制的时候，在安排任务的时候就需要显式的唤醒一下了
synchronized (mailBox){
mailBox.notify();
}
}
public Timer(){
//创建一个线程，让这个线程去扫描队列的队首元素
Thread worker=new Thread(){
@Override
public void run() {
while (true){
//取出队首元素，判定一下这个元素能不能执行
try {
Task task=queue.take();
long currentTime=System.currentTimeMillis();
if(currentTime>=task.time){
//时间到了执行任务
task.run();
}else{
//时间没到，继续等待
queue.put(task);
synchronized (mailBox){
mailBox.wait(task.time-currentTime);
}
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
worker.start();
}
}
}
总结
本篇文章就到这里了，希望能给你带来帮助，也希望您能够多多关注编程网的更多内容！
