多线程案例(单例、阻塞队列、生消模型、定时器)

最新推荐文章于 2024-08-12 20:23:48 发布
最新推荐文章于 2024-08-12 20:23:48 发布
阅读量133 收藏 1
点赞数
文章标签： 单例模式 定时器 阻塞队列 生产者消费者
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_60631323/article/details/126440441
版权
本文深入探讨了Java中的设计模式，重点讲解了单例模式的饿汉和懒汉实现，以及它们的线程安全性。接着介绍了阻塞队列的概念，包括生产者消费者模型，并展示了标准库中 BlockingQueue 的使用及自定义阻塞队列的模拟实现。最后，讨论了定时器的原理，分析了标准库 Timer 类的使用，并给出了模拟定时器的实现及优化过程。
摘要由CSDN通过智能技术生成

目录

一、单例模式

单例模式是校招中最常考的设计模式之一.

1.1 概念

设计模式好比象棋中的 “棋谱”. 红方当头炮, 黑方马来跳. 针对红方的一些走法, 黑方应招的时候有一些固定的套路. 按照套路来走局势就不会吃亏.
软件开发中也有很多常见的 “问题场景”. 针对这些问题场景, 大佬们总结出了一些固定的套路. 按照这个套路来实现代码, 也不会吃亏.
单例模式能保证某个类在程序中只存在唯一一份实例, 而不会创建出多个实例(借助语法，强行限制不能创建多个实例，避免程序员不小心出错)， 比如 JDBC 中的 DataSource 实例就只需要一个

单例模式具体的实现方式, 分成 “饿汉” 和 “懒汉” 两种.

1.2 饿汉模式

类加载的同时, 创建实例.

【代码实现】

class Singleton{
    private static Singleton instance=new Singleton();
    private Singleton(){

    }
    public static Singleton getInstance(){
        return instance;
    }
}

在这里插入图片描述
饿汉模式在多线程的环境下也是线程安全的，因为在多线程中调用getInstance方法时，只涉及多线程的读，故是线程安全的

1.3 懒汉模式

类加载的时候不创建实例. 第一次使用的时候才创建实例.
懒这个词，在计算机中往往意味着性能比较高
懒汉这种模式在计算机中很常见，例如现在有个10G的文件存储在硬盘中，通过编辑器打开这个文件

  • 把10G文件都读取到内存中，读取完毕之后再允许用户进行查看和修改【饿汉】
  • 只读取一页(当前屏幕能显出的范围)，随着用户翻页，继续读后续内容，用户没翻到这一页，就先不去读【懒汉】

对比之下，懒汉形式的效率更高；还有我们生活中的微信朋友圈的图片，在你点开之前显示的都是缩略图，只有在你点开某个图片后才会真正加载原图

【线程不安全版】

class SingletonLazy{
    private static SingletonLazy instance=null;
    private SingletonLazy(){};
    public static SingletonLazy getInstance(){
        if(instance==null){
            instance=new SingletonLazy();
        }
        return instance;
    }
}

在这里插入图片描述
线程安全问题发生在首次创建实例时. 如果在多个线程中同时调用 getInstance 方法，多个线程都发现instance为null，就可能导致创建出多个实例.一旦实例已经创建好了, 后面再多线程环境调用 getInstance 就不再有线程安全问题了(不再修改instance了)

【线程安全版】

class SingletonLazy{
    private static volatile SingletonLazy instance=null;
    private SingletonLazy(){};
    public static SingletonLazy getInstance(){
        if(instance==null) {
            synchronized (SingletonLazy.class) {
                if (instance == null) {
                    instance = new SingletonLazy();
                }
            }
        }
        return instance;
    }
}

在这里插入图片描述

但在网上对于volatile在此处起的作用还有些争议，有的人还认为此处volatile的作用是禁止指令的重排序
在这里插入图片描述

【举例理解双重if起到的作用】

(1) 有三个线程, 开始执行 getInstance , 通过外层的 if (instance == null)
知道了实例还没有创建的消息. 于是开始竞争同一把锁
在这里插入图片描述
(2) 其中线程1 率先获取到锁, 此时线程1 通过里层的 if (instance == null) 进一步确认实例是否已经创建.
如果没创建, 就把这个实例创建出来.
在这里插入图片描述
(3)当线程1 释放锁之后, 线程2 和 线程3 也拿到锁, 也通过里层的 if (instance == null)
来确认实例是否已经创建, 发现实例已经创建出来了, 就不再创建了.
在这里插入图片描述
(4) 后续的线程, 不必加锁, 直接就通过外层 if (instance == null) 就知道实例已经创建了, 从而不再尝试获取锁了.
降低了开销.
在这里插入图片描述

二、阻塞队列

2.1 概念

阻塞队列是一种特殊的队列. 也遵守 “先进先出” 的原则.
阻塞队列能是一种线程安全的数据结构, 并且具有以下特性:

  • 当队列满的时候, 继续入队列就会阻塞, 直到有其他线程从队列中取走元素
  • 当队列空的时候, 继续出队列也会阻塞(本质上就是修改了线程的状态，让线程的PCB在内核中暂时不参与调度), 直到有其他线程往队列中插入元素.

【补充】：

  1. 阻塞队列是线程安全的，因为内部内置了锁和同步机制能保证线程安全
  2. 无锁队列：线程安全的队列，实现内部没有使用锁，更高效，但会消耗更多的CPU资源
  3. 消息队列：在队列中涵盖多种不同"类型"的元素，取元素的时候可以按照某个类型来取，做到针对该类型的"先进先出" (甚至会把消息队列作为服务器，单独部署，例如kafka，rocketmq等)

阻塞队列的一个典型应用场景就是 “生产者消费者模型”. 这是一种非常典型的开发模型.

2.2 生产者消费者模型

生产者消费者模式就是通过一个容器来解决生产者和消费者的强耦合问题。
生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取.
阻塞队列起到的作用：
(1) 阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力

比如在 “秒杀” 场景下, 服务器同一时刻可能会收到大量的支付请求. 如果直接处理这些支付请求, 服务器可能扛不住(每个支付请求的处理都需要比较复杂的流程). 这个时候就可以把这些请求都放 到一个阻塞队列中, 然后再由消费者线程慢慢的来处理每个支付请求. 这样做可以有效进行 “削峰”, 防止服务器被突然到来的一波请求直接冲垮.

(2) 阻塞队列也能使生产者和消费者之间解耦.

比如过年一家人一起包饺子. 一般都是有明确分工, 比如一个人负责擀饺子皮, 其他人负责包. 擀饺子皮的人就是 “生产者”, 包饺子的人就是 “消费者”. 擀饺子皮的人不关心包饺子的人是谁(能包就行, 无论是手工包, 借助工具, 还是机器包), 包饺子的人也不关心擀饺子皮的人是谁(有饺子皮就行, 无论是用擀面杖擀的, 还是拿罐头瓶擀, 还是直接从超市买的).

2.3 标准库中的阻塞队列

在 Java 标准库中内置了阻塞队列. 如果我们需要在一些程序中使用阻塞队列, 直接使用标准库中的即可。

  • BlockingQueue 是一个接口. 真正实现的类是 LinkedBlockingQueue.
  • put 方法用于阻塞式的入队列, take 用于阻塞式的出队列.
  • BlockingQueue 也有 offer, poll, peek 等方法, 但是这些方法不带有阻塞特性.

【代码示例：生产者消费者模型】

package thread;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class Test1 {
    public static void main(String[] args) {
        BlockingQueue<Integer> queue=new LinkedBlockingQueue<>();
        Thread customer=new Thread(()->{
            while (true){
                try {
                   int val= queue.take();
                    System.out.println("消费元素:"+val);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        customer.start();
        Thread producer=new Thread(()->{
            int n=0;
           while(true){
               System.out.println("生产元素:"+n);
               try {
                   queue.put(n);
                   n++;
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }

           }
        });
        producer.start();
    }
}

执行结果：
在这里插入图片描述

2.4 阻塞队列模拟实现

  • 基于数组实现队列
  • 提供两种核心方法：put和take
  • 使用 synchronized 进行加锁控制.
package thread;

public class MyBlockingQueue {
    private int[] items=new int[1000];
    //队列的头的位置
    private int head=0;
    //队列尾的位置
    private int tail=0;
    //队列中元素的个数
    private volatile int size=0;
  public void put(int val) throws InterruptedException {
      synchronized (this){
        // 此处最好使用 while
          // 否则 notifyAll 的时候, 该线程从 wait 中被唤醒,
       // 但是紧接着并未抢占到锁. 当锁被抢占的时候, 可能又已经队列满了
        // 就只能继续等待
          while(size==items.length){
         this.wait();
          }
          items[tail]=val;
          tail++;
          if(tail == items.length){
              tail=0;
          }
          size++;
          this.notify();
      }

  }
  public Integer take() throws InterruptedException {
      int ret=0;
      synchronized (this){
         while(size==0){
            this.wait();
          }
          ret=items[head];
          head++;
          if(head==items.length){
              head=0;
          }
          size--;
          this.notify();
      }
      return ret;
  }
}

在这里插入图片描述

【注意】：

put函数中的this.wait和this.notify take函数中的this.wait和this.notify
这几个this都指的是同一个对象，因为只有对同一个队列进行put和take才会造成阻塞

【代码示例：生产者消费者模型】

   public static void main(String[] args) {
        MyBlockingQueue queue=new MyBlockingQueue();
        Thread customer=new Thread(()->{
            while(true){
                int val= 0;
                try {
                    val = queue.take();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("消费了:"+val);
            }
        });
        customer.start();
        Thread producer=new Thread(()->{
            int n=0;
            while (true){
                try {
                    queue.put(n);
                    System.out.println("生产了:"+n);
                    n++;
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        producer.start();
    }

执行结果：
在这里插入图片描述

三、定时器

3.1 概念

定时器也是软件开发中的一个重要组件. 类似于一个 “闹钟”. 达到一个设定的时间之后, 就执行某个指定好的代码.
在这里插入图片描述

定时器是一种实际开发中非常常用的组件.
比如网络通信中, 如果对方 500ms 内没有返回数据, 则断开连接尝试重连.
比如一个 Map, 希望里面的某个 key 在 3s 之后过期(自动删除).
类似于这样的场景就需要用到定时器.

3.2 标准库中的定时器

  • 标准库中提供了一个 Timer 类(java.util包下). Timer 类的核心方法为 schedule
  • schedule 包含两个参数. 第一个参数指定即将要执行的任务代码, 第二个参数指定多长时间之后执行 (单位为毫秒).
package thread;

import java.util.Timer;
import java.util.TimerTask;

public class Test2 {
    public static void main(String[] args) {
        Timer timer=new Timer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("hello timer");
            }
        },5000);
    }
}

执行结果：
在这里插入图片描述

【补充】：

TimerTask 类实现了Runnable接口
在这里插入图片描述

【定时器和sleep的区别】：

使用sleep会把当前的线程给阻塞掉
使用定时器，当前线程不会阻塞

【使用定时器】


import java.util.Timer; import java.util.TimerTask;

public class Test2 {
    public static void main(String[] args) throws InterruptedException {
        Timer timer=new Timer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("hello timer");
            }
        },5000);
        while (true){
            System.out.println("main");
            Thread.sleep(1000);
        }
    } }

执行结果：
在这里插入图片描述

【 使用sleep】


import java.util.Timer; import java.util.TimerTask;

public class Test2 {
    public static void main(String[] args) throws InterruptedException {
        Thread.sleep(5000);
        System.out.println("hello timer");
        while (true){
            System.out.println("main");
            Thread.sleep(1000);
        }
    } }

执行结果：
在这里插入图片描述

3.3 模拟实现定时器

定时器的构成：

  • 一个带优先级的阻塞队列

为啥要带优先级呢?
因为阻塞队列中的任务都有各自的执行时刻 (delay). 最先执行的任务一定是 delay 最小的. 使用带优先级的队列就可以高效的把这个 delay 最小的任务找出来

  • 队列中的每个元素是一个Task对象
  • Task中带有时间属性
  • 同时还要有一个worker线程，线程一直扫描队首元素，看队首元素是否需要执行

(1) Timer 类提供的核心接口为 schedule, 用于注册一个任务, 并指定这个任务多长时间后执行.

public class MyTimer {
     //command 要执行的任务
    //after 该任务多久后开始执行
    public void schedule(Runnable command,long after){

    }
}

(2) Task 类用于描述一个任务. 里面包含一个 Runnable 对象和一个 time(毫秒时
间戳)这个对象需要放到 优先队列 中. 因此需要实现 Comparable 接口.

class Task implements Comparable<Task>{
    private  Runnable command;
    private long time;
    public Task(Runnable command,long after){
        this.command=command;
        //此处记录的是绝对的时间戳
        this.time=System.currentTimeMillis()+after;
    }
    //执行任务的方法，直接在内部调用Runnable的run方法即可
    public void run(){
        command.run();
    }

    @Override
    public int compareTo(Task o) {
        //时间小的排在前面
        return (int)(this.time-o.time);
    }
    public long getTime() {
        return time;
    }

}

(3)Timer 实例中, 通过 PriorityBlockingQueue 来组织若干个 Task 对象.
通过 schedule 来往队列中插入一个个 Task 对象.

public class MyTimer {
    private PriorityBlockingQueue<Task> queue=new PriorityBlockingQueue<>();

    //command 要执行的任务
    //after 该任务多久后开始执行
    public void schedule(Runnable command,long after){
     Task task=new Task(command, after);
     queue.put(task);
    }
}

(4) Timer 类中存在一个 worker 线程, 一直不停的扫描队首元素, 看看是否能执行这个任务.

package thread;

import javax.rmi.ssl.SslRMIClientSocketFactory;
import java.util.concurrent.PriorityBlockingQueue;

class Task implements Comparable<Task>{
    private  Runnable command;
    private long time;
    public Task(Runnable command,long after){
        this.command=command;
        //此处记录的是绝对的时间戳
        this.time=System.currentTimeMillis()+after;
    }
    //执行任务的方法，直接在内部调用Runnable的run方法即可
    public void run(){
        command.run();
    }

    @Override
    public int compareTo(Task o) {
        //时间小的排在前面
        return (int)(this.time-o.time);
    }

    public long getTime() {
        return time;
    }

    public void setTime(long time) {
        this.time = time;
    }
}
public class MyTimer {
    private PriorityBlockingQueue<Task> queue=new PriorityBlockingQueue<>();

    //command 要执行的任务
    //after 该任务多久后开始执行
    public void schedule(Runnable command,long after){
     Task task=new Task(command, after);
         queue.put(task);
         queue.notify();
    }
    public  MyTimer(){
        Thread worker=new Thread(()->{
            while(true){
                //循环过程中获取队首元素
                //判断队首元素是否可以执行
                try {
                    Task task=queue.take();
                    long curTime= System.currentTimeMillis();
                    if(task.getTime()>curTime){
                        //还没到应该执行此任务的时间
                         queue.put(task);
                    }else{
                      task.run();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        worker.start();
    }
}

【bug分析】：当前的代码存在一个严重的问题，就是while(true)转的太快了，造成了无意义的CPU浪费

比如第一个任务设定的是 1 min 之后执行某个逻辑. 但是这里的 while (true) 会导致每秒钟访问队首元素几万次. 而当前距离任务执行的时间还有很久呢.

【bug处理】：使用wait和notify

(5) 引入locker对象，借助该对象的 wait / notify 来解决 while (true) 的忙等问题

package thread;

import javax.rmi.ssl.SslRMIClientSocketFactory;
import java.util.concurrent.PriorityBlockingQueue;

class Task implements Comparable<Task>{
    private  Runnable command;
    private long time;
    public Task(Runnable command,long after){
        this.command=command;
        //此处记录的是绝对的时间戳
        this.time=System.currentTimeMillis()+after;
    }
    //执行任务的方法，直接在内部调用Runnable的run方法即可
    public void run(){
        command.run();
    }

    @Override
    public int compareTo(Task o) {
        //时间小的排在前面
        return (int)(this.time-o.time);
    }

    public long getTime() {
        return time;
    }

    public void setTime(long time) {
        this.time = time;
    }
}
public class MyTimer {
    private Object locker=new Object();
    private PriorityBlockingQueue<Task> queue=new PriorityBlockingQueue<>();

    //command 要执行的任务
    //after 该任务多久后开始执行
    public void schedule(Runnable command,long after){
     Task task=new Task(command, after);
         queue.put(task);
        //每次有新任务到来的时候唤醒一下 worker 线程. (因为新插入的任务可能
       // 是需要马上执行的).
         synchronized (locker){
             locker.notify();
         }
    }
    public  MyTimer(){
        Thread worker=new Thread(()->{
            while(true){
                //循环过程中获取队首元素
                //判断队首元素是否可以执行
                try {
                    Task task=queue.take();
                    long curTime= System.currentTimeMillis();
                    if(task.getTime()>curTime){
                        //还没到应该执行此任务的时间
                         queue.put(task);
                         synchronized (locker){
                             locker.wait(task.getTime()-curTime);
                         }
                    }else{
                      task.run();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        worker.start();
    }
    
}

【bug分析】：即使我们引入了wait和notify解决了CPU忙等的问题，但该代码仍然存在bug
在这里插入图片描述
【解决办法】：扩大锁的范围

package thread;

import javax.rmi.ssl.SslRMIClientSocketFactory;
import java.util.concurrent.PriorityBlockingQueue;

class Task implements Comparable<Task>{
    private  Runnable command;
    private long time;
    public Task(Runnable command,long after){
        this.command=command;
        //此处记录的是绝对的时间戳
        this.time=System.currentTimeMillis()+after;
    }
    //执行任务的方法，直接在内部调用Runnable的run方法即可
    public void run(){
        command.run();
    }

    @Override
    public int compareTo(Task o) {
        //时间小的排在前面
        return (int)(this.time-o.time);
    }

    public long getTime() {
        return time;
    }

    public void setTime(long time) {
        this.time = time;
    }
}
public class MyTimer {
    private Object locker=new Object();
    private PriorityBlockingQueue<Task> queue=new PriorityBlockingQueue<>();

    //command 要执行的任务
    //after 该任务多久后开始执行
    public void schedule(Runnable command,long after){
     Task task=new Task(command, after);
        synchronized (locker){
        //这里的put操作也要放在锁中，如果将put放在锁的外面，仍有可能出现上面的
        //bug(在取完队首元素后，还没等到执行wait就有新任务插入)
         queue.put(task);
         //每次有新任务到来的时候唤醒一下 worker 线程. (因为新插入的任务可能
         // 是需要马上执行的).
            locker.notify();
         }
    }
    public  MyTimer(){
        Thread worker=new Thread(()->{
            while(true){
                //循环过程中获取队首元素
                //判断队首元素是否可以执行
                try {
                    synchronized (locker) {
                        Task task = queue.take();
                        long curTime = System.currentTimeMillis();
                        if (task.getTime() > curTime) {
                            //还没到应该执行此任务的时间
                            queue.put(task);

                            locker.wait(task.getTime() - curTime);

                        } else {
                            task.run();
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        worker.start();
    }
}

上述的代码仍存在一个问题，就是可能出现"死等"
在这里插入图片描述
【完整代码】：

package thread;

import javax.rmi.ssl.SslRMIClientSocketFactory;
import java.util.concurrent.PriorityBlockingQueue;

class Task implements Comparable<Task>{
    private  Runnable command;
    private long time;
    public Task(Runnable command,long after){
        this.command=command;
        //此处记录的是绝对的时间戳
        this.time=System.currentTimeMillis()+after;
    }
    //执行任务的方法，直接在内部调用Runnable的run方法即可
    public void run(){
        command.run();
    }

    @Override
    public int compareTo(Task o) {
        //时间小的排在前面
        return (int)(this.time-o.time);
    }

    public long getTime() {
        return time;
    }

    public void setTime(long time) {
        this.time = time;
    }
}
public class MyTimer {
    private Object locker=new Object();
    private PriorityBlockingQueue<Task> queue=new PriorityBlockingQueue<>();

    //command 要执行的任务
    //after 该任务多久后开始执行
    public void schedule(Runnable command,long after){
     Task task=new Task(command, after);
        synchronized (locker){
         queue.put(task);
         //每次有新任务到来的时候唤醒一下 worker 线程. (因为新插入的任务可能
         // 是需要马上执行的).
            locker.notify();
         }
    }
    public  MyTimer(){
        Thread worker=new Thread(()->{
            while(true){
                //循环过程中获取队首元素
                //判断队首元素是否可以执行
                try {
                    synchronized (locker) {
                        while (queue.isEmpty()){
                            locker.wait();
                        }
                        Task task = queue.take();
                        long curTime = System.currentTimeMillis();
                        if (task.getTime() > curTime) {
                            //还没到应该执行此任务的时间
                            queue.put(task);
                            locker.wait(task.getTime() - curTime);
                        } else {
                            task.run();
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        worker.start();
    }

}
No regrets、
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
MFC中利用多线程实现定时器
04-26
其中，多线程技术可以用于实现复杂的并发操作，包括创建定时器功能。本篇文章将详细探讨如何在MFC中利用多线程来实现定时器。 首先，我们需要了解MFC中的`CWinThread`类，它是所有线程的基础类。创建一个新的线程时...
JavaScript是否可实现多线程 深入理解JavaScript定时机制
12-10
然而，Web Workers并不能完全实现真正的多线程，它们仍然受限于主线程的事件驱动模型，不能直接通信，而是通过消息传递来协作。 总的来说，JavaScript通过单线程、事件循环和异步任务队列的机制，实现了看似多线程...
实验七多线程编程_JAVA
baiqiaoxiang的博客
12-11 735
实验目的： （1）了解进程和线程的概念 （2）了解多线程编程的特点 （3）利用Thread类和Runnable接创建多线程类 （4）掌握线程类的常用方法 （5）掌握多线程同步的方法 实验内容： 1、利用多线程类实现20个偶数和20个奇数的随机输出。 2、利用多线程编程实现多个窗口卖票的问题： （1）三个窗口同时各卖10张票； （2）三个窗口共同卖10张票。 3、编写多线程程序，实现生产者、消费者线程，并实现线程的同步： （1）生产者线程产生20个数，消费者线程输出生产者线程产生的这20个数。 （2）使用线程
java定时器+多线程(池)+java队列Demo
09-06
在“java定时器+多线程(池)+java队列Demo”这个项目中，我们将深入探讨这三个核心概念。 1. **Java定时器（java.util.Timer）**：`Timer`类用于调度周期性的任务执行。它可以安排一个任务在未来某个时间点或定期...
JavaScript单线程和任务队列原理解析
10-15
由于多线程操作DOM可能导致复杂的同步问题，JavaScript被设计为单线程，以简化编程逻辑。然而，为了充分利用多核处理器的能力，HTML5引入了Web Worker，但这并未改变JavaScript的单线程本质，因为Web Worker仍然受限...
详解spring多线程与定时任务
08-30
【Spring多线程任务】 Spring框架提供了一种优雅的方式来处理多线程任务，这主要得益于其内置的任务执行器（TaskExecutor）接口。TaskExecutor接口允许开发者定义如何执行异步任务，而Spring通过实现该接口提供了...
C++实现单例模式/工厂模式
meeiuliuus的博客
08-08 250
单例模式即一个类只创建一个实例，提供一个全局访问点。单例模式主要是为了控制资源访问，在一些功能如：数据库连接池，日志类实例，线程池等都可以采用单例模式。
单例模式（懒汉模式，饿汉模式）
记录C++/Linux/操作系统的学习
08-08 502
线程安全的懒汉单例模式：懒汉单例模式是在调用函数的时候生成的，为了防止同一个线程调用需要加上互斥锁。同时减小锁的粒度，采用锁+双重判断的方式。极为简洁的懒汉单例模式：在局部的静态变量中默认存在着互斥锁，本身不存在线程安全问题，所以在局部变量的情况下不需要维护线程安全问题。单例的饿汉模式：在主函数未调用之前该单例就已经存在了，所以不存在线程安全的问题。
编程-设计模式 3：单例模式
qq_45831414的博客
08-09 412
定义：单例模式确保一个类只有一个实例，并提供一个全局访问点来访问该实例。目的：这种模式通常用于那些需要频繁访问且只需一个实例的对象，例如配置管理器、日志记录器等。
《单例模式的深度解读：实现方式、破坏情况与利弊权衡》
面团到油条的成长日记
08-12 585
单例模式在特定场景下能够发挥其优势，有效地管理资源和控制访问，但在扩展性方面存在一定的局限性。在实际应用中，需要根据具体需求权衡其利弊，选择是否使用单例模式。
Java设计模式-单例模式最佳实践
欢迎拜读我的作品，喜欢的领域请给我留言
08-10 1552
好啦，以上就是关于java设计模式的单例模式详细介绍，整理出八种初始化方式及其利弊分析，最佳方式推荐是3.4章节的线程安全单例。
单例模式（懒汉式、饿汉式）
m0_74249133的博客
08-08 386
单例模式三要素：构造方法私有化静态属性指向实例的方法，返回自己创建的静态属性。
单例模式（Singleton Pattern）
m0_65347933的博客
08-07 640
一、单例模式的实现方式：1. 懒汉式（Lazy Initialization）；2. 线程安全的懒汉式；3. 双重检索锁（Double-Check Locking）；4. 饿汉式（Hungry Initialization）；5. 使用枚举。二、使用单例模式的注意事项：1、序列化保护；2、懒加载和性能；3、内存泄露
设计模式 - 单例模式
菜鸟小码的博客
08-09 779
单例模式是一种常用的创建型设计模式，它确保一个类只有一个实例，并提供一个全局访问点来访问这个实例。这种模式对于那些需要频繁创建和销毁对象的场合非常有用，例如日志记录器、缓存管理器、数据库连接池等。本文将详细介绍单例模式的实现原理，并通过具体的Java代码示例来说明如何实现这一模式。
单例模式和多例模式具有什么区别？
weixin_54503231的博客
08-12 153
多例模式（Multiton Pattern）：也称为有限状态机模式或有限实例模式，它是单例模式的一种扩展，允许一个类有多个实例，但实例的数量是有限的。这种模式的目的是在需要时创建多个实例，但又要控制实例的总数，以避免资源过度使用。单例模式和多例模式是两种常见的软件设计模式，它们都属于对象创建型模式，但在实例的创建和管理上有着本质的区别。单例模式：适用于那些在整个系统中只需要一个实例的场景，如配置文件的读取、线程池、数据库连接池等。多例模式：根据需求，可以有多个实例，但实例的总数受到控制，不会无限制地增长。
人力资源+大数据+薪酬报告+涨薪调薪，在学习、工作生活中，越来越多的事务都会使用到报告，通常情况下，报告的内容含量大、篇幅较长
08-12
人力资源+大数据+薪酬报告+涨薪调薪，在学习、工作生活中，越来越多的事务都会使用到报告，通常情况下，报告的内容含量大、篇幅较长。那么什么样的薪酬报告才是有效的呢？以下是小编精心整理的调薪申请报告，欢迎大家分享。相信老板看到这样的报告，一定会考虑涨薪的哦。
SEQ投诉处理与VONR信令及特性介绍
08-12
SEQ平台5G分析模块介绍 投诉分析处理 VoNR信令及特性介绍
毕业设计php企业进销存管理系统-qkrp源码含文档工具包
最新发布
08-12
毕业设计php企业进销存管理系统-qkrp源码含文档工具包 php，数据库mysql，jdk1.8，开发工具用ecplise、myecplise、sts、idea都可以 类型管理 商品管理 库存查看 库存查看 入库查看 出库查看 用户管理 包含：源码、数据库脚本、论文、环境工具包、相同框架项目的安装教程（在说明文档中）
大学生电子设计大赛-《高频电子线路》实验指导书.rar
08-12
大学生电子设计大赛-《高频电子线路》实验指导书.rar
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值