02 Singleton单例

已于 2024-01-10 21:06:13 修改
阅读量457 收藏 8
点赞数 13
文章标签： 单例模式 设计模式
于 2024-01-09 22:21:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/i973635025/article/details/135490215
版权

抽丝剥茧设计模式 之 Singleton单例 - 更多内容请见 目录

文章目录

一、Singleton单例

Singleton单例常用于manager等只需要有一个实例的地方，但是由于正常情况我们无法阻止其他人创建实例，所以我们需要用Singleton单例模式来约束。
Singleton单例模式有8种写法，但是只有两种（7、8）完美无缺，但是完美的不常用。

二、单例模式的八种实现

1、饿汉式1

Java实现

/**
 * 饿汉式
 * 类加载到内存后，就实例化一个单例，JVM，保证线程安全，
 * 简单实用，推荐使用。
 * 唯一缺点，不管用到与否，类装载时就完成了实例化。
 */
  
public class Singleton {
    // 私有静态成员变量，直接创建实例
    private static final Singleton instance = new Singleton();

    // 私有构造方法，防止外部实例化
    private Singleton() { }

    // 公有静态方法，获取实例
    public static Singleton getInstance() {
        return instance;
    }
    
}

public class Main {
    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        System.out.println(singleton.hashCode());

        Singleton anotherSingleton = Singleton.getInstance();
        System.out.println(anotherSingleton.hashCode());

        // 输出结果应为相同的hashCode，表示只有一个实例被创建
    }
}

go实现

package main

import (
    "fmt"
    "sync"
)

// 饿汉式
type Singleton struct{}

// 私有静态成员变量，直接创建实例
var instance *Singleton = &Singleton{}
var once sync.Once

// 公有静态方法，获取实例
func GetInstance() *Singleton {
    return instance
}

func main() {
    singleton := GetInstance()
    fmt.Println(singleton.hash())

    anotherSingleton := GetInstance()
    fmt.Println(anotherSingleton.hash())

    // 输出结果应为相同的hashCode，表示只有一个实例被创建
}

func (s *Singleton) hash() int {
    return int(uintptr(unsafe.Pointer(s)))
}

2、饿汉式2

Java实现

/**
 * 饿汉式
 * 用静态语句块保证当getInstance()调用时才创建实例
 */


public class Singleton {
    // 私有静态成员变量，用静态语句块创建实例
    private static final Singleton instance;
    static {
        instance = new Singleton();
    }

    // 私有构造方法，防止外部实例化
    private Singleton() { }

    // 公有静态方法，获取实例
    public static Singleton getInstance() {
        return instance;
    }
    
}

public class Main {
    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        System.out.println(singleton.hashCode());

        Singleton anotherSingleton = Singleton.getInstance();
        System.out.println(anotherSingleton.hashCode());

        // 输出结果应为相同的hashCode，表示只有一个实例被创建
    }
}

go实现

package main

import (
    "fmt"
    "sync"
)

// 饿汉式
type Singleton struct{}

// 私有静态成员变量，直接创建实例
var instance *Singleton
var once sync.Once

// 公有静态方法，获取实例
func GetInstance() *Singleton {
    once.Do(func() {
        instance = &Singleton{}
    })
    return instance
}

func main() {
    singleton := GetInstance()
    fmt.Println(singleton.hash())

    anotherSingleton := GetInstance()
    fmt.Println(anotherSingleton.hash())

    // 输出结果应为相同的hashCode，表示只有一个实例被创建
}

func (s *Singleton) hash() int {
    return int(uintptr(unsafe.Pointer(s)))
}

3、懒汉式

Java实现

/**
 * 懒汉式
 * 虽然达到了按需初始化的目的，但却带来了线程不安全的问题。
 */
  
public class Singleton {
    // 私有静态成员变量
    private static Singleton instance;

    // 私有构造方法，防止外部实例化
    private Singleton() { }

    // 公有静态方法，获取实例
    public static /*synchronized*/ Singleton getInstance() {
        if (instance == null) {
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            instance = new Singleton();
        }
        return instance;
    }
    
}

public class Main {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                Singleton singleton = Singleton.getInstance();
                System.out.println(Thread.currentThread().getName() + " - " + singleton.hashCode());
            }).start();
        }
    }
}

go实现

package main

import (
    "fmt"
    "sync"
)

// 懒汉式
type Singleton struct{}

var instance *Singleton
var once sync.Once

// 公有静态方法，获取实例
func GetInstance() *Singleton {
    if instance == nil {
        instance = &Singleton{}
    }
    return instance
}

func main() {
    singleton := GetInstance()
    fmt.Println(singleton.hash())

    anotherSingleton := GetInstance()
    fmt.Println(anotherSingleton.hash())

    // 输出结果应为相同的hashCode，表示只有一个实例被创建
    wg := sync.WaitGroup{}
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            singleton := GetInstance()
            fmt.Println(singleton.hash())
        }()
    }
    wg.Wait()
}

func (s *Singleton) hash() int {
    return int(uintptr(unsafe.Pointer(s)))
}

4、懒汉式-加锁

Java实现

/**
 * 懒汉式
 * 虽然达到了按需初始化的目的，但却带来了线程不安全的问题。
 */
  
public class Singleton {
    // 私有静态成员变量
    private static Singleton instance;

    // 私有构造方法，防止外部实例化
    private Singleton() { }

    // 公有静态方法，获取实例
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            instance = new Singleton();
        }
        return instance;
    }
    
}

public class Main {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                Singleton singleton = Singleton.getInstance();
                System.out.println(Thread.currentThread().getName() + " - " + singleton.hashCode());
            }).start();
        }
    }
}

go实现

package main

import (
    "fmt"
    "sync"
)

// 懒汉式
type Singleton struct{}

var instance *Singleton
var once sync.Once
var mu sync.Mutex

// 公有静态方法，获取实例
func GetInstance() *Singleton {
    mu.Lock()
    defer mu.Unlock()

    if instance == nil {
        instance = &Singleton{}
    }
    return instance
}

func main() {
    singleton := GetInstance()
    fmt.Println(singleton.hash())

    anotherSingleton := GetInstance()
    fmt.Println(anotherSingleton.hash())

    // 输出结果应为相同的hashCode，表示只有一个实例被创建
    wg := sync.WaitGroup{}
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            singleton := GetInstance()
            fmt.Println(singleton.hash())
        }()
    }
    wg.Wait()
}

func (s *Singleton) hash() int {
    return int(uintptr(unsafe.Pointer(s)))
}

5、懒汉式-缩小加锁代码块

Java实现

/**
 * 懒汉式
 * 虽然达到了按需初始化的目的，但却带来了线程不安全的问题。
 */
  
public class Singleton {
    // 私有静态成员变量
    private static Singleton instance;

    // 私有构造方法，防止外部实例化
    private Singleton() { }

    // 公有静态方法，获取实例
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                instance = new Singleton();
            }
        }
        return instance;
    }
}

public class Main {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                Singleton singleton = Singleton.getInstance();
                System.out.println(Thread.currentThread().getName() + " - " + singleton.hashCode());
            }).start();
        }
    }
}

go实现

package main

import (
    "fmt"
    "sync"
)

// 懒汉式
type Singleton struct{}

var instance *Singleton
var once sync.Once
var mu sync.Mutex

// 公有静态方法，获取实例
func GetInstance() *Singleton {
    if instance == nil {
        mu.Lock()
        instance = &Singleton{}
        mu.Unlock()
    }
    return instance
}

func main() {
    singleton := GetInstance()
    fmt.Println(singleton.hash())

    anotherSingleton := GetInstance()
    fmt.Println(anotherSingleton.hash())

    // 输出结果应为相同的hashCode，表示只有一个实例被创建
    wg := sync.WaitGroup{}
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            singleton := GetInstance()
            fmt.Println(singleton.hash())
        }()
    }
    wg.Wait()
}

func (s *Singleton) hash() int {
    return int(uintptr(unsafe.Pointer(s)))
}

6、懒汉式-双判断

Java实现

/**
 * 懒汉式
 * 虽然达到了按需初始化的目的，但却带来了线程不安全的问题。
 */
  
public class Singleton {
    // 私有静态成员变量
    private static volatile Singleton instance;

    // 私有构造方法，防止外部实例化
    private Singleton() { }

    // 公有静态方法，获取实例
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
            	if (instance == null) {
            		try {
	                    Thread.sleep(1);
	                } catch (InterruptedException e) {
	                    e.printStackTrace();
	                }
	                instance = new Singleton();
            	}
            }
        }
        return instance;
    }
}

public class Main {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                Singleton singleton = Singleton.getInstance();
                System.out.println(Thread.currentThread().getName() + " - " + singleton.hashCode());
            }).start();
        }
    }
}

go实现

package main

import (
    "fmt"
    "sync"
)

// 懒汉式
type Singleton struct{}

var instance *Singleton
var once sync.Once
var mu sync.Mutex

// 公有静态方法，获取实例
func GetInstance() *Singleton {
    if instance == nil {
        mu.Lock()
        if instance == nil {
        	instance = &Singleton{}
        }
        mu.Unlock()
    }
    return instance
}

func main() {
    singleton := GetInstance()
    fmt.Println(singleton.hash())

    anotherSingleton := GetInstance()
    fmt.Println(anotherSingleton.hash())

    // 输出结果应为相同的hashCode，表示只有一个实例被创建
    wg := sync.WaitGroup{}
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            singleton := GetInstance()
            fmt.Println(singleton.hash())
        }()
    }
    wg.Wait()
}

func (s *Singleton) hash() int {
    return int(uintptr(unsafe.Pointer(s)))
}

7、静态内部类-同时保证线程安全和懒加载

Java实现

/**
 * 靠JVM保证线程安全
 * 当外部类被加载时，内部类不会被加载
 * 当getInstance()被调用，SingletonHolder被加载
 * SingletonHolder是内部类，可以调用私有的构造器
 */
  
public class Singleton {
    // 私有构造方法，防止外部实例化
    private Singleton() { }

	private static class SingletonHolder {
		// 私有静态成员变量
    	private final static Singleton instance = new Singleton();
	}
	public static Singleton getInstance() {
		return SingletonHolder.instance;
	}
}

public class Main {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                Singleton singleton = Singleton.getInstance();
                System.out.println(Thread.currentThread().getName() + " - " + singleton.hashCode());
            }).start();
        }
    }
}

8、枚举单例

Java实现

/**
 * 枚举单例，不仅解决线程同步，还可以防止反序列化
 */
public enum Singleton {
	instance;
}

public class Main {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + " - " + Singleton.instance.hashCode());
            }).start();
        }
    }
}

总结

老实用第一种就可以了。最后两种我没想好该怎么对应go的语法，容我想想。

李海成
关注
  • 13
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
singleton单例模式1
08-08
"singleton单例模式1" 单例设计模式是软件设计模式中的一种，目的是确保某个类只能有一个实例，并提供一个全局的访问点来访问这个实例。 首先，单例模式的要点是：① 某个类只能有一个实例。构造器私有化。② 它...
Qt qml Singleton 单例模式
03-27
此示例展示了Qml 的单例模式（类似全局对象，只生成一次实例，可全局使用） surfsky.cnblogs.com
singleton单例模式
01-16
c++ singleton单例模式
Singleton 单例模式
03-16
NULL 博文链接：https://walson.iteye.com/blog/392190
Singleton单例模式.zip
12-14
C# 23种设计模式之单例模式源码
JavaScript设计模式 Item 6 --单例模式Singleton_js单例模式的生命周期
2401_85124323的博客
06-24 307
这个对象可以被修改。你可以添加属性和方法。你也可以用delete运算符删除现有成员。这实际上违背了面向对象设计的一条原则：**类可以被扩展，但不应该被修改。**如果某些变量需要保护，那么可以将其定义在闭包中。对象字面量只是创建单例的方法之一。也并非所有的对象字面量都是单例，那些只是用来模仿关联数组或容纳数据的对象字面量显然不是单例。
Java面试题：讨论单例模式的实现方式，包括懒汉式和饿汉式，并讨论线程安全问题
码农超哥的博客
06-23 410
单例模式（Singleton Pattern）是一种设计模式，确保一个类只有一个实例，并提供一个全局访问点。单例模式在某些场景下很有用，例如配置管理、日志记录等。以下是单例模式的两种主要实现方式：懒汉式（Lazy Initialization）和饿汉式（Eager Initialization），以及它们在多线程环境中的线程安全问题。
什么是Java中的单例模式？请列举几种常见的单例实现方式，并讨论其优缺点。请解释Java中的设计模式，并列举几种常见的设计模式及其应用场景。
weixin_53180424的博客
06-20 726
什么是Java中的单例模式？请列举几种常见的单例实现方式，并讨论其优缺点。Java中的单例模式是一种创建型设计模式，它确保一个类只有一个实例，并提供一个全局访问点来访问这个实例。这种模式在多线程环境中特别有用，因为它可以确保线程安全，避免资源冲突。instanceinstance请解释Java中的设计模式，并列举几种常见的设计模式及其应用场景。Java中的设计模式是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。
javascript设计模式---单例模式
最新发布
m0_73280507的博客
06-26 125
单例模式又称为单体模式，并提供一个访问它的全局访问点，也就是说，第二次使用同一个类创建的对象的时候，应该得到和第一次创建的对象完全相同的对象。
【设计模式】【创建型5-1】【单例模式】
SHI_IHS的博客
06-26 146
此时 第一个创建了新的对象返回 如果没有第二次判空校验 那么 第二个会在第一个释放锁以后 重新创建对象 这就是有问题的 此时如果有判空的话 可以避免此场景。代码中 假设两个线程 都通过了第一判空 阻塞在synchronized锁上 其中一个获取锁成功 另外一个阻塞，比如要在内存里记录一些东西。可能使用饿汉模式直接存储。使用双重锁校验模式，创建线程池。为什么要做双重锁校验。一般配置只能有一份。
设计模式——工厂方法模式
橘猫的博客
06-23 321
工厂方法模式（Factory Method Pattern）是一种创建型设计模式，它定义了一个用于创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法让一个类的实例化延迟到其子类。
设计模式——责任链
qq_50595984的博客
06-26 463
责任链模式是一种行为设计模式，用于将请求的发送者和接收者解耦。在这种模式中，请求通过一条由多个对象组成的链传递，直到有一个对象能够处理该请求为止。每个对象都可以决定是否处理请求以及是否将请求传递给下一个对象。处理请求的对象可能不确定：当请求的处理对象需要动态确定时，可以使用责任链模式。责任链模式允许请求在链中传递，直到有一个处理者能够处理该请求。需要避免发送者和接收者之间的耦合：责任链模式可以将发送者和接收者解耦，发送者不需要知道具体的接收者是谁，只需要将请求发送给责任链的第一个处理者即可。
c++设计模式之一创建型模式
weixin_41199566的博客
06-20 324
不同之处在于，在 Animal 类中我们添加了一个 performAction() 方法，该方法调用了 makeSound() 方法。在 main() 函数中，根据用户的选择实例化不同的子类，并通过基类指针调用 performAction() 方法。这样，具体调用哪个子类的方法由子类自己实现，父类并不知道具体的子类实例化。在 main() 函数中，我们使用指向基类的指针 animal，通过 new 实例化具体的子类，并调用其方法。只能在父类中写方法调用，具体调用哪一个类的方法交给子类实现。
设计模式深入解析与实例应用
weixin_46608377的博客
06-26 790
责任链模式（Chain of Responsibility Pattern）是一种行为设计模式，它允许将请求沿着处理者链进行传递，直到找到能够处理该请求的处理者。每个处理者都包含对下个处理者的引用，如果一个处理者不能处理请求，则会将请求传递给链中的下一个处理者。这样，多个对象都有机会处理请求，从而避免了请求发送者与接收者之间的耦合。优点解耦：发送请求的对象与处理请求的对象解耦，两者不直接关联，易于扩展和维护。简化对象：每个处理者只需关注自己的处理逻辑，不需要知道完整的请求处理链。
【Unity设计模式】状态编程模式
milu_ELK的博客
06-20 1104
最近在学习Unity游戏设计模式，看到两本比较适合入门的书，一本是unity官方的,另一本是这两本书介绍了大部分会使用到的设计模式，因此很值得学习本专栏暂时先记录一些教程部分，深入阅读后续再更新。
Python 设计模式(第2版) -- 第三部分（行为型模式）
Talk is cheap, show the code.
06-20 864
再介绍下行为型设计模式。行为型模式，顾名思义，它主要关注的是对象的责任。它们用来处理对象之间的交互，以实现更大的功能。行为型模式建议：对象之间应该能够彼此交互，同时还应该是松散耦合的。观察者设计模式是最简单的行为型模式之一，所以，首先来看看观察者设计模式。
Java中的设计模式：实战案例分享
weixin_44626980的博客
06-21 512
单例模式确保一个类只有一个实例，并提供一个全局访问点。它常用于需要全局唯一实例的场景，如配置管理、日志记录等。工厂模式定义了一个创建对象的接口，但由子类决定实例化哪一个类。它通过延迟到子类来实现实例化，提供了对象创建的灵活性。观察者模式定义了对象间的一对多依赖关系，当一个对象的状态发生变化时，所有依赖于它的对象都会收到通知并自动更新。该模式常用于事件处理系统中。策略模式定义了一系列算法，并将每个算法封装起来，使它们可以相互替换。策略模式使得算法可以独立于使用它的客户端变化。
常见的结构型设计模式
qq_62989250的博客
06-21 422
常见的结构型设计模式
【设计模式之策略模式 -- C++】
qq_44628330的博客
06-22 371
策略模式（Strategy Pattern）是一种行为设计模式，它定义了一系列算法，并将每一个算法封装起来，使它们可以互相替换。策略模式让算法的变化独立于使用算法的客户。
spring中singleton是单例模式吗
05-01
是的，Spring中的Singleton就是单例模式的一种实现。在Spring中，Singleton是指在整个应用程序中只存在一个实例，所有的请求都是针对同一个实例进行处理。这种实现方式可以提高性能，避免资源浪费，同时也方便了应用...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值