多线程(七）：单例模式+阻塞式队列

最新推荐文章于 2023-01-13 21:46:21 发布
最新推荐文章于 2023-01-13 21:46:21 发布
阅读量179 收藏
点赞数
分类专栏： Java学习 文章标签： 多线程 java 设计模式 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Kaiiiiiiiiiiiiii/article/details/117409436
版权

多线程(七）：单例模式+阻塞式队列

单例模式

单例模式：整个程序的运行中只存储了一个对象。

饿汉模式

优点：不用加锁也是线程安全的。

饿汉模式的实现，示例代码如下：

/*
 * 饿汉模式
 */

public class ThreadDemo84 {
    static class Singleton {
        //1.创建私用的构造函数（防止其他类直接创建）
        private Singleton() {
        }

        //2.定义私有变量(线程安全)
        private static Singleton singleton = new Singleton();

        //3.提供公共的获取实例的方法
        public static Singleton getInstance() {
            return singleton;
        }
    }
    
    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        System.out.println(singleton);
    }
}

该代码的执行结果如下：
在这里插入图片描述
单例模式的饿汉模式成功得到创建。

缺点：程序启动之后就会创建，但是创建完了之后有可能不会使用，从而浪费了系统资源。

所以我们需要另一种单例模式——懒汉模式。

懒汉模式

当程序启动之后并不会进行初始化；而是在什么时候调用，什么时候再初始化。

版本1，示例代码如下：

/*
 * 懒汉模式 v1
 */

public class ThreadDemo85 {
    static class Singleton {
        //1.创建私用的构造函数（防止其他类直接实例化）
        private Singleton() {
        }

        //2.定义私有变量(线程安全)
        private static Singleton singleton = null;

        //3.提供公共的获取实例的方法
        public static Singleton getInstance() {
            if (singleton == null) {
                singleton = new Singleton();
            }
            return singleton;
        }
    }

    public static void main(String[] args) {
        //创建第一个对象
        Singleton s1 = Singleton.getInstance();
        //创建第二个对象
        Singleton s2 = Singleton.getInstance();
        System.out.println(s1 == s2);
    }
}

该代码的执行结果如下：
在这里插入图片描述
我们发现，两个对象使用的是同一个私有变量。但是，此代码存在问题：会造成线程不安全，示例代码如下：

/*
 * 懒汉模式 v1
 */

public class ThreadDemo86 {
    static class Singleton {
        //1.创建私用的构造函数（防止其他类直接实例化）
        private Singleton() {
        }

        //2.定义私有变量(线程安全)
        private static Singleton singleton = null;

        //3.提供公共的获取实例的方法
        public static Singleton getInstance() {
            if (singleton == null) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                singleton = new Singleton();
            }
            return singleton;
        }
    }

    private static Singleton s1 = null;
    private static Singleton s2 = null;

    public static void main(String[] args) throws InterruptedException {
        //创建新线程执行任务
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                s1 = Singleton.getInstance();
            }
        });
        t1.start();

        //使用主线程执行任务
        s2 = Singleton.getInstance();
        //等待t1执行完毕。
        t1.join();
        System.out.println(s1 == s2);
    }
}

该代码的执行结果如下：
在这里插入图片描述
可见，此程序是线程不安全的。

对程序进行优化，加锁可以解决线程非安全的问题，懒汉模式版本2，示例代码如下：

/*
 * 懒汉模式 v2
 */
 
public class ThreadDemo87 {
    static class Singleton {
        //1.创建私用的构造函数（防止其他类直接实例化）
        private Singleton() {
        }

        //2.定义私有变量(线程安全)
        private static Singleton singleton = null;

        //3.提供公共的获取实例的方法
        public static synchronized Singleton getInstance() {
            if (singleton == null) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                singleton = new Singleton();
            }
            return singleton;
        }
    }

    private static Singleton s1 = null;
    private static Singleton s2 = null;

    public static void main(String[] args) throws InterruptedException {
        //创建新线程执行任务
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                s1 = Singleton.getInstance();
            }
        });
        t1.start();

        //使用主线程执行任务
        s2 = Singleton.getInstance();
        //等待t1执行完毕。
        t1.join();
        System.out.println(s1 == s2);
    }
}

该代码的执行结果如下：
在这里插入图片描述
我们发现：该程序的线程不安全问题得到解决，但是，此程序会带来新的问题：无论是否为第一次访问，都需要排队执行，造成性能不佳。
我们对此程序再进行优化（使用双重校验锁< Double Check >），懒汉模式版本3，示例代码如下：

/*
 * 懒汉模式 v3
 */

public class ThreadDemo88 {
    static class Singleton {
        //1.创建私用的构造函数（防止其他类直接实例化）
        private Singleton() {
        }

        //2.定义私有变量(线程安全)
        private static Singleton singleton = null;

        //3.提供公共的获取实例的方法
        public static Singleton getInstance() {
            if (singleton == null) {
                synchronized (Singleton.class) {
                    if (singleton == null) {
                        singleton = new Singleton();
                    }
                }
            }
            return singleton;
        }
    }

    private static Singleton s1 = null;
    private static Singleton s2 = null;

    public static void main(String[] args) throws InterruptedException {
        //创建新线程执行任务
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                s1 = Singleton.getInstance();
            }
        });
        t1.start();

        //使用主线程执行任务
        s2 = Singleton.getInstance();
        //等待t1执行完毕。
        t1.join();
        System.out.println(s1 == s2);
    }
}

该程序的运行结果如下：
在这里插入图片描述
此代码当然还是有问题的，问题在于singleton = new Singleton();此行代码编译器会进行指令重排序，因此我们需要进一步优化，我们可以得到懒汉模式的最终版本

/*
 * 懒汉模式 v final
 */

public class ThreadDemo88 {
    static class Singleton {
        //1.创建私用的构造函数（防止其他类直接实例化）
        private Singleton() {
        }

        //2.定义私有变量(线程安全)(volatile)
        private static volatile Singleton singleton = null;

        //3.提供公共的获取实例的方法
        public static  Singleton getInstance() {
            if (singleton == null) {
                synchronized (Singleton.class) {
                    if (singleton == null) {
                        singleton = new Singleton();
                    }
                }
            }
            return singleton;
        }
    }

    private static Singleton s1 = null;
    private static Singleton s2 = null;

    public static void main(String[] args) throws InterruptedException {
        //创建新线程执行任务
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                s1 = Singleton.getInstance();
            }
        });
        t1.start();

        //使用主线程执行任务
        s2 = Singleton.getInstance();
        //等待t1执行完毕。
        t1.join();
        System.out.println(s1 == s2);
    }
}

自定义阻塞队列

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

在这里插入图片描述
示例代码如下：

public class ThreadDemo89 {
    static class MyBlockingQueue {
        private int[] values;//实际存储数据的数组
        private int first;//队首
        private int last;//队尾
        private int size;//队列元素的实际大小

        public MyBlockingQueue(int initial) {
            //初始化变量
            values = new int[initial];
            first = 0;
            last = 0;
            size = 0;
        }

        //添加元素（队尾）
        public void offer(int val) {
            synchronized (this) {
                //判断边界值
                if (size == values.length) {
                    //队列已满,阻塞等待
                    try {
                        this.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //添加元素到队尾
                values[last++] = val;
                size++;
                //判断当前值是否为最后一个元素
                if (last == values.length) {
                    last = 0;
                }
                //尝试唤醒消费者
                this.notify();
            }
        }

        //查询方法
        public int poll() {
            int result = -1;
            synchronized (this) {
                //判断边界值
                if (size == 0) {
                    //队列为空，阻塞等待
                    try {
                        this.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //获取元素
                result = values[first++];
                size--;
                //判断是否为最后一个元素
                if (first == values.length) {
                    first = 0;
                }
                //尝试唤醒生产者
                this.notify();
            }
            return result;
        }
    }

    public static void main(String[] args) {

        MyBlockingQueue myBlockingQueue = new MyBlockingQueue(100);

        //创建生产者
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                //每隔500ms，生产一个数据
                while (true) {
                    int num = new Random().nextInt(10);
                    System.out.println("生产了随机数：" + num);
                    myBlockingQueue.offer(num);
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        t1.start();

        //创建消费者
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    int result = myBlockingQueue.poll();
                    System.out.println("消费了数据：" + result);
                }
            }
        });
        t2.start();
    }
}

该代码的执行结果如下：
在这里插入图片描述
生产者生产一个数据，消费者就消费了此数据。
可见，我们实现了自定义阻塞队列。

头发都哪去了
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
单例模式，阻塞队列，定时器
AIJXB的博客
06-13 323
单例模式 是多线程的一个案例，是一种常见的设计模式。 两种实现单例模式的方法： 1、饿汉模式 2、懒汉模式 阻塞队列 是一个先进先出的队列 入队列的时候如果发现队列满了，就会阻塞，直到有其他线程出队列后，才能继续如对类。 出队列时候如果发现队列空了，也会阻塞，直到有其他线程入队列后，才能继续出队列。 public class ThreadDemo3 { static class BlockingQueue { //基于数组实现 private int[] arra
第十四节: 介绍四大并发集合类并结合单例模式下的队列来说明线程安全和非安全的场景及补充性能调优问题。
sinolover的专栏
02-06 238
一. 四大并发集合类 背景：我们目前使用的所有集合都是线程不安全的。 　　A. ConcurrentBag：就是利用线程槽来分摊Bag中的所有数据，链表的头插法,0代表移除最后一个插入的值. 　　(等价于同步中的List) 　　B. ConcurrentStack：线程安全的Stack是使用Interlocked来实现线程安全, 而没有使用内核锁. 　　(等价于同步中的数组) 　　C...
【多线程案例】单例模式 + 阻塞式队列
xqs196301的博客
04-08 808
【多线程案例】单例模式 + 阻塞式队列
队列_单例模式
zrf的专栏
12-21 1161
数据队列，一端接收数据，一端发送数据。用于不同线程的数据共享
数据结构与算法——单列队列
wangjiaju960914的博客
08-27 357
数据结构与算法——单列队列 队列介绍 队列是一个有序列表，可以用数组或是链表来实现。 遵循先入先出的原则。即：先存入队列的数据，要先取出。后存入的要后取出 示意图：使用数组模拟队列示意图 数组模拟队列 队列本身是有序列表，若使用数组的结构来存储队列的数据，则队列数组的声明如下图, 其中 maxSize 是该队列的最大容量。 因为队列的输出、输入是分别从前后端来处理，因此需要两个变量 front及 rear分别记录队列前后端的下标，front 会随着数据输出而改变，而 rear则是随着数据输入而改变。
javalruleetcode-MyLeetCode:我的LeetCode+JZoffer算法题学习
06-29
java lru leetcode 面试题刷题，java基础知识 该仓库作为个人刷题的题目记录仓库，包含剑指Offer上的全部面试题...还包括一些java基础知识，多线程，阻塞队列实现的生产者消费者模式，缓存 单例模式，动态代理模式等。
AndroidSerialSQL:Android库可帮助访问SQLite
05-21
这比仅获取一个数据库对象（或一个可写数据库对象）的单例模式要远得多，并使用线程池执行程序来实现阻塞队列，线程池执行程序的最大大小为1。 这意味着将有一个处理数据库写操作的线程，它将通过队列中存在的请求...
leetcode下载-LeetCode-Nowcoder-DataStruct:记录日常刷题与数据结构
06-29
这个包下面的东西都是与并发编程相关的东西,比如阻塞队列实现生产者消费者模型,CAS,n种单例模式,线程交替打印,线程通信,读写锁,信号量,countdLaunch,circleBarrier等等 五. LeetCode 记录力扣刷题 由于本人不经常在...
米哈游笔试题目-Java方向.docx
03-10
单例模式的线程安全日志记录器类：需要设计一个类，保证在多线程环境下只有一个实例存在，并能够正确记录日志信息。 并发安全的阻塞队列类：需要设计一个线程安全的队列类，支持多线程的插入和移除操作，能够正确...
java面试题，180多页，绝对良心制作，欢迎点评，涵盖各种知识点，排版优美，阅读舒心
08-13
【多线程】多线程的实现方式Thread、Runnable、Callable 72 【多线程】实现Runnable接口与继承Thread类比较 73 【多线程】线程状态转换 74 【多线程】线程的调度 75 线程优先级 75 sleep 76 wait 76 yield 77 join ...
【多线程】单例模式、阻塞队列
m0_60494863的博客
06-01 385
1.单例模式 单例模式是一种设计模式，单例模式能保证某个类在程序中只存在唯一一份实例, 而不会创建出多个实例. 1.1饿汉模式 举个例子解释饿汉模式：中午使用了三个菜碟，吃完后，马上把三个碗都洗了。 通过Singleton 这个类 来实现单例模式，保证 Singleton 这个类只有唯一实例 在下面程序中使用到的 static。 static 修饰的成员更加准确的说，是“类成员”=>“类属性/类方法”。一个java 程序中，一个类对象只存在一份（JVM保证的），进一步的也就保证了类的.
【多线程经典案例】- 单例/阻塞队列/定时器/线程池
qq_45792749的博客
05-02 1709
单例模式 阻塞队列 阻塞队列是一种特殊的队列，除了具有队列的性质外，还具有阻塞的功能。例如下面的典型案例 – 生产者消费者模型 当队列满时，继续入队列就会阻塞，直到有其他线程从队列中取走元素 当队列空时，继续出队列也会阻塞，直到有其他线程往队列中插入元素 阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力 比如在 "秒杀" 场景下, 服务器同一时刻可能会收到大量的支付请求. 如果直接处理这些支付请求,服务器可能扛不住(每个支付请求的处理都需要比较复杂的流程). 这个时候就可以把这些请求都放
自己写个一个队列和单例模式
weixin_30814319的博客
11-01 294
package com.bjsxt.base.conn009; import java.util.LinkedList; import java.util.concurrent.atomic.AtomicInteger; /** * 模拟Queue * @author alienware * */ public class MyQueue { ...
成小胖学习ActiveMQ·基础篇
weixin_30908649的博客
02-10 139
过了个春节，回到公司的成小胖变成了成大胖。但是你们千万别以为他那个大肚子里面装的都是肥肉，里面的墨水也多了不少嘞，毕竟成小胖利用春节的半个月时间专心学习并研究了 ActiveMQ，嘿嘿……这不，为了检验下自己的学习成果，上班的第一天成小胖就去找架构师老王交流 ActiveMQ 相关的知识，还顺便向老王讨了个红包，可把成小胖给高兴坏了。“来，根据你的了解说下 ActiveMQ 是什么。” “这个简...
单例模式与自定义阻塞队列
ilikeu777的博客
05-28 182
提升程序性能的方法 1、多线程 2、单例模式：整个程序的运行中，只存在一个对象。 饿汉方式：上来不管啥先创建一个对象再说。（不用加锁也是线程安全的） 懒汉方式：当程序启动之后并不会初始化，而是在什么时候调用，什么时候再初始化。 设计模式： 1、单例模式（手写） 2、工厂模式（简单工厂、抽象工厂） 3、模板模式 … 饿汉方式 public class ThreadDemoEH1 { static class Singleton{ //1、创建私有的构造函数(为了防止其他类直接创建)
Java EE|多线程代码实例之单例模式与阻塞队列
moteandsunlight的博客
01-13 631
JAVAEE|多线程|代码实例|单例模式|阻塞队列
C++学习笔记（四）——栈，队列与单例模式
weixin_39828926的博客
02-10 273
C++学习笔记（四）——栈，队列与单例模式 本文通过原理解释与代码实现两个方面来解释栈、队列与单例模式。 栈的原理与实现 栈是一种==“先进后出”==的数据结构，示意图如下图（图一）： 图一就是一个栈的示意图，该栈的大小为8，现有6个元素。栈顶（_top）元素为5。对栈的操作有： 初始化：创建一个空栈 压栈：将一个元素放入栈中 出栈：将栈顶元素拿出栈 判空：判断栈是否为空 清空：清空栈的所有元...
方法加载时间长---1单例模式 2消息队列
自古红蓝出CP的博客
09-14 623
背景：写了一个方法，遍历循环数据，耗时两三分钟，影响体验 一、想到了 static 静态变量或静态块，在项目启动时就加载变量，访问时可直接使用，避免了访问时加载时长的问题 二、由静态变量或静态块，想到了单例模式，在网上搜索有基于枚举的单例模式，参考：单例模式中为什么用枚举更好 、如何创建一个完美的单例模式、java单例之enum实现方式 自己写了一个单例，访问时长由两三分钟缩短为二三十秒，...
单例模式实现 线程安全的队列 处理
NuClear的.Net专栏
10-16 2140
public sealed class Queue_Lucene //利用队列 处理Lucene.Net增加索引     {         private static Queue_Lucene instance = null;         private Queue_Lucene()         {         }         public static Queue
线程安全的单例模式 饿汉式
最新发布
04-10
饿汉式是一种线程安全的单例模式，它的特点是在类加载时就创建了实例对象，因此也被称为静态初始化方式。下面是饿汉式的实现方式： 1. 将类的构造函数私有化，使得外部无法直接创建对象。 2. 在类内部定义一个私有...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值