Java多线程(单例模式,堵塞队列,定时器)详解

目录

• 一、单例模式

• 饿汉模式

• 懒汉模式

• 懒汉模式

• 二、堵塞队列

• 实现BlockingQueue

• 三、定时器

• 总结

一、单例模式

单例模式是一种设计模式，针对一些特定的场景，研究出对应的解决方案，。有些对象在代码中只应该有一个实例，单例模式就是强制某个类只能有一个实例。

单例模式的实现，主要依托于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();
       }
   }
}

来源：https://blog.csdn.net/weixin_51601437/article/details/119575737