多线程与单例模式

最新推荐文章于 2024-07-25 13:59:31 发布
最新推荐文章于 2024-07-25 13:59:31 发布
阅读量638 收藏 2
点赞数 4
分类专栏： 多线程 文章标签： 多线程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44991304/article/details/115267274
版权

立即加载/饿汉模式

立即加载是指在使用类的时候对象已经创建完毕，常见的实现方法是直接new实例化。在立即加载/饿汉模式中，调用方法前，实例已经被创建了，下面来看一下实现代码：

package com.single.thread;

public class SingleInstance {
    private static SingleInstance instance=new SingleInstance();
    private SingleInstance(){}
    public static SingleInstance getInstance(){
        return instance;
    }
}
class test{
    public static void main(String[] args) {
        Thread thread=new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(SingleInstance.getInstance().hashCode());
            }
        });
        Thread thread1 = new Thread(thread);
        Thread thread2 = new Thread(thread);
        Thread thread3 = new Thread(thread);

        thread1.start();
        thread2.start();
        thread3.start();
    }
}
测试结果：
2084620955
2084620955
2084620955

控制台输出的结果看出hashcode是一个值完成了立即加载的单例模式。但是缺点是不能拥有其他的实例变量，因为getinstance方法不是同步的，所以可能出现非线程安全问题。

延迟加载/懒汉模式

延迟加载是指调用方法的时候对象才实例化。

package com.single.thread;

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

class test2{
    public static void main(String[] args) {
        Thread thread=new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(SingleInstance2.getInstance().hashCode());
            }
        });
        Thread thread1 = new Thread(thread);
        Thread thread2 = new Thread(thread);
        Thread thread3 = new Thread(thread);

        thread1.start();
        thread2.start();
        thread3.start();
    }
}
结果：
34369211
1712447624
1300234150

控制台输出的hashcode不同说明创建了三个对象并不是单例的。

懒汉模式的解决方案

只需要在getinstance方法上加上同步关键字synchronized
package com.single.thread;

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

class test2{
    public static void main(String[] args) {
        Thread thread=new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(SingleInstance2.getInstance().hashCode());
            }
        });
        Thread thread1 = new Thread(thread);
        Thread thread2 = new Thread(thread);
        Thread thread3 = new Thread(thread);

        thread1.start();
        thread2.start();
        thread3.start();
    }
}
结果：

1746582977
1746582977
1746582977

此方法加上synchronized关键字得到了相同的实例对象，但是这种方法效率低，是同步运行的。下一个线程必须等上一个线程释放锁才能进入此方法。
能否使用同步代码块来解决下面来看一个案例

package com.single.thread;

public class SingleInstance3 {
    private static SingleInstance3 instance;
    private SingleInstance3(){}
    public  static SingleInstance3 getInstance(){
        try {
            if(instance==null){
                Thread.sleep(200);
                synchronized (SingleInstance3.class) {
                    instance = new SingleInstance3();
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }

        return instance;
    }
}

class test3{
    public static void main(String[] args) {
        Thread thread=new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(SingleInstance3.getInstance().hashCode());
            }
        });
        Thread thread1 = new Thread(thread);
        Thread thread2 = new Thread(thread);
        Thread thread3 = new Thread(thread);

        thread1.start();
        thread2.start();
        thread3.start();
    }
}
结果：
1877212914
847086262
1688623490

此方法使用同步synchronized语句块对实例化对象的关键代码进行同步，运行效率得到了提升，但是从结果上来看并没有解决多线程问题。下面使用
双检查锁机制来解决多线程下加载饿汉单例模式。

package com.single.thread;

public class SingleInstance4 {
    private volatile static SingleInstance4 instance;
    private SingleInstance4(){}
    public  static SingleInstance4 getInstance(){
        try {
            if(instance==null){
                Thread.sleep(200);
                synchronized (SingleInstance4.class) {
                    if(instance==null)
                    instance = new SingleInstance4();
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }

        return instance;
    }
}

class test4{
    public static void main(String[] args) {
        Thread thread=new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(SingleInstance4.getInstance().hashCode());
            }
        });
        Thread thread1 = new Thread(thread);
        Thread thread2 = new Thread(thread);
        Thread thread3 = new Thread(thread);

        thread1.start();
        thread2.start();
        thread3.start();
    }
}
结果：
1688623490
1688623490
1688623490

使用volatile关键字可以使instance变量在多线程间达到可见性，另外也会禁止指令重排，因为 instance = new SingleInstance4()代码在内存部分为三个部分
1）memory=allocate(); //分配对象的内存空间
2) ctorInstance(memory); //初始化对象
3）instance=memory; //设置instance指向刚分配的内存地址

JIT编译器有可能将这三个步骤重排序成：

1）memory=allocate(); //分配对象的内存空间
2) instance=memory; //设置instance指向刚分配的内存地址
3）ctorInstance(memory); //初始化对象
这时候将会出现以下情况：虽然构造方法还没有执行，但是instance对象有了内存地址，值不是null，当访问instance对象中的实量还是默认数据类型的默认值。

使用静态内部类实现单例模式

public class SingleInstance5 {

    private SingleInstance5(){}
    private  static class InnerInstance{
        private static SingleInstance5 instance=new SingleInstance5();
    }
    public static SingleInstance5 getInstance(){

        return InnerInstance.instance;
    }
}

class test5{
    public static void main(String[] args) {
        Thread thread=new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(SingleInstance5.getInstance().hashCode());
            }
        });
        Thread thread1 = new Thread(thread);
        Thread thread2 = new Thread(thread);
        Thread thread3 = new Thread(thread);

        thread1.start();
        thread2.start();
        thread3.start();
    }
}
结果：
38910761
38910761
38910761

从控制台输出的结果来看可以知道静态内部类可以实现单例模式。

序列化与反序列化的单列模式实现

public class User {

}
package com.single.xue;

import java.io.ObjectStreamException;
import java.io.Serializable;

public class MyObject implements Serializable {
    private static final long serialVersionUID=666L;
    public static User user=new User();
    private static MyObject myObject=new MyObject();
    private MyObject(){

    }
    public static MyObject getInstance(){
        return myObject;
    }
    //该方法在反序列化时不创建新的instance对象
    protected Object readResolve() throws ObjectStreamException {
        System.out.println("该方法被调用了");
        return MyObject.myObject;
    }
}

测试类：

import java.io.*;

public class Test {
    public static void main(String[] args) {
        MyObject instance = MyObject.getInstance();
        FileOutputStream fileOutputStream=null;
        ObjectOutputStream objectOutputStream=null;
        FileInputStream fileInputStream=null;
        ObjectInputStream objectInputStream=null;
        try {
            System.out.println("序列化——instance=" + instance.hashCode() + "\t" +
                    "user=" + MyObject.user.hashCode());
            fileOutputStream = new FileOutputStream(new File("e:\\myObject.txt"));
            objectOutputStream = new ObjectOutputStream(fileOutputStream);
            objectOutputStream.writeObject(instance);
            fileOutputStream.close();
            objectOutputStream.close();
        }catch (Exception e){
            e.printStackTrace();
        }
        try{
            fileInputStream=new FileInputStream(new File("e:\\myObject.txt"));
            objectInputStream=new ObjectInputStream(fileInputStream);
            MyObject object = (MyObject)objectInputStream.readObject();
            fileInputStream.close();
            objectInputStream.close();
            System.out.println("序列化——instance=" + instance.hashCode() + "\t" +
                    "user=" + MyObject.user.hashCode());
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}
结果：
序列化——instance=557041912	user=1134712904
该方法被调用了
序列化——instance=557041912	user=1134712904

静态代码块实现单例模式

package com.single.thread;

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

class test6{
    public static void main(String[] args) {
        Thread thread=new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(SingleInstance6.getInstance().hashCode());
            }
        });
        Thread thread1 = new Thread(thread);
        Thread thread2 = new Thread(thread);
        Thread thread3 = new Thread(thread);

        thread1.start();
        thread2.start();
        thread3.start();
    }
}
结果：
566612817
566612817
566612817

静态代码块在使用类的时候就已经执行，所有可以应用静态代码块的这个特性来实现单例。

使用enum枚举数据类型来实现单例模式

public class MyObject {
    public enum myEnumSingleton{
        users;
        private User user;

        private myEnumSingleton() {
            user=new User();
        }
        public User getUser(){
            return user;
        }
    }
    public static User getUser(){
        return myEnumSingleton.users.getUser();
    }
}
class User{

}
class Tests{
    public static void main(String[] args) {
        Thread thread=new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 2; i++) {
                    System.out.println(MyObject.getUser().hashCode());
                }
            }
        });
        Thread thread1 = new Thread(thread);
        Thread thread2 = new Thread(thread);
        Thread thread3 = new Thread(thread);

        thread1.start();
        thread2.start();
        thread3.start();
    }
}
结果：
370102716
370102716
370102716
370102716
370102716
370102716

enum枚举类型的特性和静态代码块的特性相似，在使用枚举类时，构造方法会被自动调用，所有可以用来实现单例模式。

活跃的咸鱼
关注
专栏目录
单例模式和多线程
Angus的博客
04-24 346
立即加载/饿汉模式 立即加载就是在使用类之前已经将对象创建完毕，常见的实现方法就是new实例化。 public class MyThread { private static MyThread INSTANCE = new MyThread(); private MyThread() {} public static MyThread getInstance() { ...
【多线程】单例模式与多线程
柠檬树
02-08 668
一、前言 如何使单例模式遇到多线程是安全的、正确的？ 我们在学习设计模式的时候知道单例模式有懒汉式和饿汉式之分。简单来说，饿汉式就是在使用类的时候已经将对象创建完毕，懒汉式就是在真正调用的时候进行实例化操作。二、饿汉式+多线程 public class MyObject { //饿汉模式 private static MyObject myObjec...
多线程和单例
m0_52450868的博客
07-30 113
多线程和单例 1. 多线程 1.1 线程的生命周期 1.2 线程通信涉及到的方法 所有方法的都来自Object类，以下方法都是通过【锁对象调用】 void wait(); 在哪一个线程代码中执行，哪一个线程进入阻塞状态。【开启锁对象】 static Thread currentThread(); void notify(); 通过锁对象调用，唤醒通过当前锁对象限制的进入休眠状态的一个线程。【开启锁对象】 void notifyAll(); 通过锁对象调用，唤醒通过当前锁对象限制的进入休
【多线程】单例模式
最新发布
weixin_62848751的博客
07-25 1320
单例模式是一种经典的设计模式它确保一个类只有一个实例，并提供一个全局访问点来获取该实例。单例模式主要用于控制对某些共享资源的访问，例如配置管理器、连接池、线程池、日志对象等。
Java多线程实战之单例模式与多线程的实例详解
08-26
Java多线程实战之单例模式与多线程的实例详解 单例模式是Java多线程编程中最常用的设计模式之一，它的主要作用是确保一个类在应用程序中只有一个实例，并提供一个全局访问点。单例模式有多种实现方式，如饿汉模式、...
java多线程之线程安全的单例模式
09-02
在多线程环境下，线程安全的单例模式尤其重要，因为如果不正确地实现，可能会导致多个线程创建多个实例，违反了单例模式的基本原则。本文将详细介绍Java中线程安全的单例模式，包括懒汉式和饿汉式两种实现方式。 1....
详解python实现线程安全的单例模式
09-20
然而，如果我们想要在类级别实现线程安全的单例模式，就需要考虑多线程环境下的并发问题。 在给出的代码中，首先定义了一个装饰器`Singleton`，它的目的是确保每次调用时返回的是同一个实例。装饰器内部维护了一个...
C++ 多线程和多线程下的单例模式
01-08
本资源描述了C++11 中多线程的创建，C++11中std命名空间中将boost库中的Thread加入，boost多线程从准标准变为标准，其中还介绍了C++ 多线程下的单例模式的使用，本文档为txt文档
使用C++11实现线程安全的单例模式
04-05
线程安全的单例模式在多线程环境下尤其重要，因为不正确的实现可能导致多个线程创建多个实例，这违反了单例模式的基本原则。C++11引入了新的特性，如std::mutex和std::call_once，使得实现线程安全的单例模式变得...
单例模式与多线程
初心魏的博客
08-12 248
一、单例模式 1.1 立即加载/饿汉模式 立即加载就是使用类的时候已经创建完毕 立即加载： public class single { static User user = new User(); public static User getInstance(){ return user; } } 测试： @Override public ...
多线程模式中的单例
我爱编程持之以恒
03-05 470
单例相关知识参考《JAVA设计模式之单例模式》。单例模式，最常见的就是饥饿模式、懒汉模式，一个直接实例化对象，一个在调用方法时进行实例化对象。在多线程模式中，考虑到性能和线程安全问题，我们一般选择下面两种比较经典的单例模式，在性能提高的同时，又保证了线程安全。dubble check instance//懒汉式单例类.在第一次调用的时候实例化自己 public class Singleton {...
【Java多线程】——单例模式与多线程
名侦探张六儿的博客
05-27 334
    在常用的23种设计模式中，单例模式是很常用的一种。但是当单例模式与上多线程的时候，如果没有注意特殊情况，可能会产生一些意想不到的异常，有可能会导致灾难性的后果。下面我们就来研究一下单例模式再多线程环境下的应用。首先先简单的介绍一下单例模式。一、“饿汉模式”和“懒汉模式”    1、饿汉模式    首先，单例模式简单的说就是一个类在整个程序的运行过程中只创建唯一的一个实例化对象。所有有关这个...
单例模式(懒汉与恶汉)
崔崇东的博客
01-16 881
恶汉单例模式 public class Singletion { private static class InnerSingletion { private static Singletion single = new Singletion(); } public static Singletion getInstance(){
单例和多线程
Leon_Jinhai_Sun的博客
12-24 215
public class ConnThreadLocal { public static ThreadLocal&lt;String&gt; th = new ThreadLocal&lt;String&gt;(); public void setTh(String value){ th.set(value); } public void getTh(){ System....
多线程下单例模式实现
liqingtx的专栏
08-11 729
方法一：   public class DCLSingleton{   private static volatile DCLSingleton instance;   private DCLSingleton(){};   public static DCLSingleton getInstance(){     if(instance==null){       synchronized(...
单例模式（多线程）
weixin_44571405的博客
06-28 73
单例
Java多线程实现线程安全单例模式解析
"本文主要探讨了Java多线程环境下的线程安全单例模式，包括其概念、特点以及两种常见的实现方式：懒汉式和饿汉式。" 在Java编程中，单例模式是一种常用的设计模式，其核心目标是确保一个类在整个应用程序中只有一个...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

活跃的咸鱼

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值