单例模式与阻塞队列

最新推荐文章于 2024-11-11 16:38:16 发布
最新推荐文章于 2024-11-11 16:38:16 发布
阅读量43 收藏
点赞数
文章标签： 单例模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/luo_tian_yi10086/article/details/134620396
版权

文章目录

单例模式与阻塞队列

一. 单例模式

1.什么是单例模式

我们在java中说的单例是指一个程序中某个类，只能创建出一个实例，不能创建多个实例。所以单例模式可以总结为：保证某个类的程序中只存在唯一一份实例，而不会创建出多个实例。

这里可能有人会说了，多new几次，不就创建多个对象了吗？

java语法有办法禁止多次new,在java的单例模式中，借助java语法，可以保证一个类只能new一个实例，而不能多次new。

2.单例模式的具体实现方式

单例模式可以分为多种具体的实现方式，主要的模式有两种，分为“饿汉模式”和“懒汉模式”。

2.1饿汉模式

饿汉模式：在类加载同时创建实例。

从名字中的饿汉就可以看出这种模式是非常急迫的,和类的加载同时进行。

以大学生写作业为例：某位大学生现在有4科作业，以饿汉模式来说，就相当于这位大学生在某一时间段一次性写完着4科作业。

以生活中洗碗为例：以饿汉模式来说就是吃完饭后把所有用的碗都刷干净。

总的来说，饿汉模式就是急迫的把所有事情的一次性干完。

代码实例：

class Singleton{
    private static Singleton instance = new Singleton();
    public static Singleton getInstance(){
        return instance;
    }
    private Singleton(){

    }
}
public class ThreadDemo19 {
    public static void main(String[] args) {
        Singleton s = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();
        System.out.println(s == s2);
    }
}

结合以上代码来看单例模式：

private static Singleton instance = new Singleton();

此处instance对象被static修饰，java中被static修饰的对象就是类对象，而在JVM中每个类的类对象只能有一个，所以instance对象就是唯一的实例。

private Singleton(){};

这里在Singleton类中写出私有的构造方法，保证在类外不能使用，就避免了多次new。

总的来说以上代码在类内部把实例创建好了，并且禁止了外部重新创建实例，这样就保证了单例的特性，同时上述代码在类加载的同时实例便被创建出来了，模式为饿汉模式。

2.2懒汉模式

与饿汉模式对应，懒汉模式为：类加载的时候不创建实例，在第一次使用的时候才创建实例。

以大学生写作业为例：某位大学生现在有4科作业，以懒汉模式来说，就相当于这位大学生在需要提交一科作业的时候再写这一科作业。

以生活中洗碗为例：以懒汉模式来说就是吃完饭后不刷碗，在下次吃饭时需要用到几个碗就刷几个碗。

总的来说懒汉模式就是需要做什么才做什么。

代码实例：

class SingletonLazy{
    private static SingletonLazy instance = null;
    public static SingletonLazy getInstance(){
        if (instance == null) {  
              instance = new SingletonLazy();        
        }
        return instance;
    }
    private SingletonLazy(){}
}
public class ThreadDemo20 {
    public static void main(String[] args) {
        SingletonLazy s = SingletonLazy.getInstance();
        SingletonLazy s2 = SingletonLazy.getInstance();
    
}

以上代码保证单例特性的操作和饿汉模式一样就在赘述了。

private static SingletonLazy instance = null;

这里结果为null便保证了在类加载的时候实例不会被创建出来，实现懒汉模式的一个条件。

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

在外部调用这个方法的时候如果没有实例便创建一个出来，保证了懒汉模式的另一个条件。

3. 单例模式的线程安全问题

3.1产生线程安全的原因

在具体实现方式中的两个代码实例线程是否安全？多个线程下调用getInstance()是否会出现问题？我们分开来看。

饿汉模式：

public static Singleton getInstance(){
        return instance;
    }

在饿汉模式中，该方法仅仅只进行了读操作，并没有修改，所以饿汉模式认为线程是安全的。

懒汉模式：

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

懒汉模式下，只要多次调用getInstance()方法便实现了多次new的操作，着已经违反了单例模式的特性，所以多线程下单例模式可能无法保证创建对象的唯一性。

需要用到单例模式的对象如果多次创建可能会出现大问题，例如一个单例的对象需要吃200G的内存空间，在内存空间有限的情况下多次new可能会超出服务器内存空间大小导致崩溃。

3.2解决线程安全问题

两个字：加锁！
抛出问题：锁要加在哪里？
由于多线程代码很复杂，所有并不是说加了锁，就一定线程安全了，要具体情况具体分析，以上面代码为例：

错误的实例:

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

以上错误实例，原因是因为判断和new不是一个原子操作。

修改后依然存在问题的实例：

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

这里的线程不安全只出在首次创建对象这里，一旦对象创建好了，后续调用getInstance()方法就是单纯的读操作了，就没有线程安全问题便不需要加锁，而上述代码实例任何时候调用getInstance()方法都会发生锁竞争。

双重if改善实例：

class SingletonLazy{
    private static SingletonLazy instance = null;
    public static SingletonLazy getInstance(){

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

上述代码使用了两个if(instance == null){ }，仔细看两个if之间隔了一个synchronized，两个if的目的是不一样的。
外层的if是判定当下是否把instance实例创建出来了，当这个实例创建完了之后，其他竞争锁的线程就被里层的if挡住了也就不会继续创建其他实例。

volatile改善后最终实例：

class SingletonLazy{
    private volatile static SingletonLazy instance = null;
    public static SingletonLazy getInstance(){

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

乍眼一看这个实例和双重if的没有任何区别呀，仔细看对比
双重if实例：

private static SingletonLazy instance = null;

此处实例：

private volatile static SingletonLazy instance = null;

仅仅只多了一个volatile而已，但是不要小看这一个volatile，它的作用很大。
volatile避免了内存可见性，禁止了指令的重排序。

二.阻塞队列

1.什么是阻塞队列

我们先回顾一下什么是队列。

队列：一种先进先出的线性表。

那么阻塞队列是什么呢？

阻塞队列是一种特殊的队列，也遵循先进先出原则。
阻塞队列是一种线程安全的数据结构，并且有2个特性：

  • 当队列为空的时候，尝试出队列就会阻塞等待，等待到队列不为空为止。
  • 当队列是满的时候，尝试入队列也会阻塞等待，等待到队列不满为止。

简易的实例：

package thread;

import java.util.concurrent.BlockingDeque;
import java.util.concurrent.LinkedBlockingDeque;

public class ThreadDemo21 {
    public static void main(String[] args) throws InterruptedException {
        BlockingDeque<String> blockingDeque = new LinkedBlockingDeque<>();
        blockingDeque.put("hello");
        String res = blockingDeque.take();
        System.out.println(res);
        res = blockingDeque.take();
        System.out.println(res);
    }
}

下面我们解析一下以上代码：

BlockingDeque<String> blockingDeque = new LinkedBlockingDeque<>();

此处new出一个阻塞队列，阻塞队列类型为BlockingDeque

blockingDeque.put("hello");

进行入队列操作

String res = blockingDeque.take();

出队列操作，如果没有put直接take就会阻塞，以上代码中我们只put了一次，但是take了两次，所以在第二次take的时候代码就会进入阻塞状态运行结果如下图。

在这里插入图片描述
可以看到程序一直在运行状态。

2.生产者消费者模型

2.1什么是生产者消费者模型

生产者消费者模式就是通过一个容器来解决生产者和消费者的强耦合问题。
生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取。

2.2阻塞队列在其中的作用
  1. 阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力，也可以叫做“削峰填谷”。

比如铁路12306国庆抢票时，服务器同一时刻可能会收到大量的支付请求，如果直接处理这些支付请求，服务器可能扛不住，这时候就可以把这些请求给放到阻塞队列里面，然后慢慢处理每一个支付请求，这就是削峰填谷，将高峰期阻塞，在低峰期处理。

  1. 阻塞队列能使生产者和消费者之间解耦。

比如五个服务器另外五个服务器之间是一对一的关系，如果此时两者挂一个，便不能完成通信流程，这样耦合性就比较高。但是加上阻塞队列就相当于，服务器之间互相都不认识，都只知道阻塞队列，五个服务器将请求放进阻塞队列，另外五个服务器从阻塞队列里面取出请求，这样任何一个服务器挂了都不会影响其他服务器。

2.3代码实例
class MyBlockingWueue{
    private int[] items = new int[1000];
    private int head =0;
    private int tail = 0;
    private int size = 0;
    public void put(int value) throws InterruptedException {
        synchronized (this) {
            while (size == items.length){
                this.wait();
            }
            items[tail] = value;
            tail++;
            if(tail >= items.length){
                tail = 0;
            }
            size++;
            this.notify();
        }
    }
    public Integer take() throws InterruptedException {
        int result;
        synchronized (this) {
            if (size == 0) {
               this.wait();
            }
            result = items[head];
            head++;
            if (head >= items.length) {
                head = 0;
            }
            size--;
            this.notify();
        }
        return result;
    }
}
public class ThreadDemo23 {
    public static void main(String[] args) throws InterruptedException {
        MyBlockingWueue queue = new MyBlockingWueue();
        Thread customer = new Thread(()->{
            while(true){
                try {
                    int result = queue.take();
                    System.out.println("消费"+result);
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        customer.start();
        Thread producer = new Thread(()->{
            int count = 0;
            while(true){
                try {
                    System.out.println("生产"+count);
                    queue.put(count);
                    count++;
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        producer.start();
    }
}

接下来我们解析一下以上代码：

class MyBlockingWueue{
    private int[] items = new int[1000];
    private int head =0;
    private int tail = 0;
    private int size = 0;
    public void put(int value) throws InterruptedException {
        synchronized (this) {
            while (size == items.length){
                this.wait();
            }
            items[tail] = value;
            tail++;
            if(tail >= items.length){
                tail = 0;
            }
            size++;
            this.notify();
        }
    }
    public Integer take() throws InterruptedException {
        int result;
        synchronized (this) {
            if (size == 0) {
               this.wait();
            }
            result = items[head];
            head++;
            if (head >= items.length) {
                head = 0;
            }
            size--;
            this.notify();
        }
        return result;
    }
}

这个实体类我们来模拟阻塞队列。

public void put(int value) throws InterruptedException {
        synchronized (this) {
            while (size == items.length){
                this.wait();
            }
            items[tail] = value;
            tail++;
            if(tail >= items.length){
                tail = 0;
            }
            size++;
            this.notify();
        }
    }

这个方法实现阻塞队列入队操作，当size达到队列最大长度时，证明阻塞队列满了，使用wait()方法让入队线程进入等待状态，一直等到notify()方法，才证明阻塞队列有空位了继续入队。

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

这个方法实现阻塞队列出队操作，当size为0时，证明阻塞队列为空，这时调用wait()使出队线程进入等待状态，一直等到相应的nofity()证明阻塞队列不为空才继续出队。

Thread producer = new Thread(()->{
            int count = 0;
            while(true){
                try {
                    System.out.println("生产"+count);
                    queue.put(count);
                    count++;
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });

这里的线程producer模拟入队操作

Thread customer = new Thread(()->{
            while(true){
                try {
                    int result = queue.take();
                    System.out.println("消费"+result);
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });

这里的customer操作模拟出队操作。

以上代码结合便构造出了一个完整的生产者消费者模型。

在这里插入图片描述

由运行结果可以看出先进行了1001次入队，这时阻塞队列满了入队线程进入wait()等待状态，这时出队线程进行一次后队列不在满并且同时调用了nofity（）解除入队线程的等待状态，然后入队线程才进行了第1002次入队。

luo_tian_yi10086
关注
多线程（【多线程案例】单例模式+阻塞式队列+定时器+线程池）
java_lujj的博客
09-25 608
（1）降低资源消耗：通过重复利用已创建的线程来执行任务，降低线程创建和消耗造成的消耗（2）提高响应速度：因为省去了创建线程这一步，所以当拿到任务时，可以立即开始执行（3）提高线程的可管理性：我们可以自己加入新的功能，比如说定时、延时来执行某些线程，也可以监控线程，控制最大并发线程数等功能。
线程池web服务器(8) 日志系统(条件变量，单例模式，阻塞队列)
ziggy7的博客
06-22 1584
整体概述 本项目中，使用单例模式创建日志系统，对服务器运行状态、错误信息和访问数据进行记录，该系统可以实现按天分类，超行分类功能，可以根据实际情况分别使用同步和异步写入两种方式。 其中异步写入方式，将生产者-消费者模型封装为阻塞队列，创建一个写线程，工作线程将要写的内容push进队列，写线程从队列中取出内容，写入日志文件。 日志系统大致可以分成两部分，其一是单例模式与阻塞队列的定义，其二是日志类的定义与使用。 基础知识 ●日志，由服务器自动创建，并记录运行状态，错误信息，访问数据的文件。 ●同步日志，日志写
【JavaEE初阶】第八节.多线程（基础篇）阻塞队列（案例二）
未央的博客哟
01-28 7633
​在单例模式之后，我们就来学习一下 第二个多线程案例 —— 阻塞队列； ​
【JavaEE】多线程代码实例：单例模式与阻塞队列BlockingQueue
yanxiang3306
02-15 7273
单例模式能保证某个类只能存在唯一的实例，不能创建多个实例。这种设计模式是需要在特定业务场景进行使用的。
单例模式与阻塞队列实现异步的日志系统
qq_41895640的博客
12-28 1981
单例模式与阻塞队列实现异步的日志系统阻塞队列定义实现(c++11)单例模式定义类型懒汉式（编程使用）饿汉式C++中static对象的初始化non-local static对象（函数外）local static 对象（函数内）异步写日志 阻塞队列 定义 在多线程编程中阻塞队列是一种常用于实现生产者和消费者模型的数据结构。其与普通的队列区别在于，当队列为空时，从队列获取元素的操作将会被阻塞，直到队列中被放入了元素；当队列满时，往队列里存放元素的操作也会被阻塞，直到有元素被从队列中取出 在c++标准库STL中常用
[线程与网络] 多线程(五):单例模式与阻塞队列
无需多言
04-26 1240
阻塞队列是⼀种特殊的队列.也遵守"先进先出"的原则.阻塞队列能是⼀种线程安全的数据结构(但是像我们前面学习的普通队列和优先级队列都是线程不安全的),并且具有以下特性:• 当队列满的时候,继续⼊队列就会阻塞,直到有其他线程从队列中取⾛元素• 当队列空的时候,继续出队列也会阻塞,直到有其他线程往队列中插⼊元素阻塞队列的⼀个典型应⽤场景就是"⽣产者消费者模型".这是⼀种⾮常典型的开发模型.拓展:消息队列。
【JavaEE】单例模式&阻塞队列
qq_53869058的博客
05-12 905
比如在 “秒杀” 场景下, 服务器同一时刻可能会收到大量的支付请求. 如果直接处理这些支付请求, 服务器可能扛不住(每个支付请求的处理都需要比较复杂的流程). 这个时候就可以把这些请求都放 到一个阻塞队列中, 然后再由消费者线程慢慢的来处理每个支付请求.擀饺子皮的人不关心包饺子的人是谁(能包就行, 无论是手工包, 借助工具, 还是机器包), 包饺子的人也不关心擀饺子皮的人是谁(有饺子皮就行, 无论是用擀面杖擀的, 还是拿罐头瓶擀, 还是直接从超市买的).
【JavaEE】多线程案例——单例模式与阻塞队列
weixin_46913665的博客
03-30 1236
文章目录一、单例模式1.饿汉模式2.懒汉模式3.线程安全的懒汉模式二、阻塞队列1.生产者消费者模型2.标准库中的阻塞队列3.生产者消费者模型4.阻塞队列实现最后的话 一、单例模式     什么是单例模式？ 单例模式是一种设计模式，这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。     什么是设计模式？ 所谓设计模式，简单来说就
基于小根堆实现定时器，利用单例模式与阻塞队列实现异步的日志系统
08-07
基于c++11的轻量级Web并发服务器，使用Epoll与Reactor高并发模型，基于小根堆实现了定时器，利用单例模式与阻塞队列实现异步的日志系统.zip优质项目，资源经过严格测试可直接运行成功且功能正常的情况才上传，可轻松...
基于c++11的轻量级Web并发服务器，基于小根堆实现了定时器，利用单例模式与阻塞队列实现异步的日志系统.zip
06-05
使用Epoll与Reactor高并发模型， C++是一种面向对象的计算机程序设计语言，由美国AT&T贝尔实验室的本贾尼·斯特劳斯特卢普博士在20世纪80年代初期发明并实现（最初这种语言被称作“C with Classes”带类的C）。它是...
多线程代码案例:单例模式/阻塞队列/线程池/定时器
yonpiguxiao的博客
10-15 1112
单例模式是一种设计模式;类似于棋谱,有固定套路,针对一些特定场景可以给出一些比较好的解决方案;只要按照设计模式来写代码,就可以保证代码不会太差,保证了代码的下限;
volatile，单例模式，阻塞队列
qq_51263139的博客
05-04 331
volatile，单例模式，阻塞队列
Spring框架之单例模式 (Singleton Pattern)
m0_61840987的博客
11-07 794
单例模式（Singleton Pattern）是一种常见的设计模式，属于创建型设计模式。它的核心思想是保证一个类只有一个实例，并且提供一个全局的访问点来获取该实例。单例模式常用于需要控制资源访问的场景，如数据库连接池、日志记录器、配置管理器等，它能够避免频繁创建对象所带来的性能开销。
《重学Java设计模式》之 单例模式
WaaTong的博客
11-07 486
单例模式主要解决的是，一个全局使用的类频繁的创建和消费，从而提升提升整体的代码的性能。
[单例模式]
2301_80313139的博客
11-07 996
单例模式简介~
Python学习从0到1 day27 Python 高阶技巧 ③ 设计模式 — 单例模式
m0_73983707的博客
11-11 250
设计模式是一种编程套路，可以极大的方便程序的开发最常见、最经典的设计模式，就是我们所学习的面向对象了。除了面向对象外,在编程中也有很多既定的套路可以方便开发,我们称之为设计模式：单例、工厂模式建造者、责任链、状态、备忘录、解释器、访问者、观察者、中介、模板、代理模式等等单例模式(Singleton Patter)是一种常用的软件设计模式，该模式的主要目的是确保某一个类只有一个实例存在。在整个系统中，某个类只能出现一个实例时，单例对象就能派上用场。
【单例模式】饿汉式与懒汉式以及线程安全
weixin_56520780的博客
11-07 1247
饿汉式单例模式：还没有获取实例对象，实例对象就已经产生了。一定是线程安全的。懒汉式单例模式：需要用的时候再构造实例。应用场景：比如日志模块，数据库模块，开发的解析器模块。
AS SSD Benchmark
最新发布
11-11
硬盘测试工具
com.harmonyos4.exception.ScalabilityLimitationException.md
11-11
鸿蒙开发中碰到的报错，问题已解决，写个文档记录一下这个问题及解决方案
Java单例模式详解与NIO优化
本文档主要介绍了Java中的单例模式（Singleton）及其两种常见的实现方式——懒汉式和饿汉式，以及NIO（Non-blocking Input/Output，非阻塞输入/输出）与传统的BIO（Blocking Input/Output，阻塞输入/输出）的区别。...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值