Golang设计模式（二）：单例模式

最新推荐文章于 2024-07-21 22:13:25 发布
最新推荐文章于 2024-07-21 22:13:25 发布
阅读量1.6k 收藏 45
点赞数 50
分类专栏： 设计模式 go语言学习 文章标签： golang 设计模式 单例模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44507495/article/details/139009329
版权

单例模式

Singletion Pattern：确保某一个类只有一个实例，而且自动执行实例化并向整个系统提供这个实例，这个类称为单例类，

使用场景

  1. 全局监控：用于全局监控统计模块，确保整个系统内监控实例的唯一性。
  2. 资源密集型类：适用于创建时消耗大量资源的类，如协程池、数据库连接池、第三方客户端等，以减少资源消耗。
  3. 配置信息共享：管理全局配置信息，确保多个模块间配置的一致性和共享。
  4. 数据库连接管理：作为数据库连接池的管理者，避免创建过多连接，提高资源利用率。
  5. 日志系统：实现线程安全的日志记录器，供多线程环境下的所有线程使用。
  6. 硬件设备管理：统一管理打印机、扫描仪等硬件设备，避免重复初始化。
  7. 资源分配：优化内存、文件句柄等有限资源的分配和管理。
  8. 服务定位：作为服务定位器，提供对系统中特定服务的全局访问。
  9. 数据缓存：实现全局缓存机制，确保数据一致性和多模块间的共享。
  10. 权限验证：构建全局权限检查器，统一权限验证流程。
  11. 状态同步：管理全局状态，如用户会话，确保状态在系统间的同步和共享。
  12. 系统组件跟踪：创建全局注册表，跟踪和管理系统内所有组件的状态。

Golang中实现单例模式的两种形式：

饿汉式与懒汉式

饿汉式

在程序启动时就创建单例对象，以确保在程序运行期间只有一个实例

饿汉式编写步骤：

  1. 私有化单例类：确保单例类和其构造函数是私有的（不可导出的），以防止外部直接实例化，从而维护单例的一致性。
  2. 预初始化实例：在程序启动时，预先创建并初始化单例对象的全局唯一实例，该实例将作为后续操作中的“单例”。
  3. 提供公共访问点：通过一个可导出的（公开的）方法 GetXXX() 向外部提供对单例对象的访问，确保全局只通过这一途径获取单例实例。

代码实例

// singleHungry 是一个单例模式的实现，用于保证全局仅有一个实例。
var s *singleHungry

// init 初始化函数，在程序启动时执行，确保 singleHungry 实例的创建。
func init(){
	s = newsingleHungry()
}

// singleHungry 结构体定义。
type singleHungry struct {
}

// newsingleHungry 创建并返回一个 singleHungry 的新实例。
func newsingleHungry() *singleHungry {
	return &singleHungry{}
}

// Work 实现了 Instance 接口的 Work 方法，打印工作信息。
func (s *singleHungry) Work() {
	fmt.Println("single hungry is working....")
}

// Instance 接口定义，规定了 Work 方法。
type Instance interface {
	Work()
}

// GetSingleHungry 返回 singleHungry 的全局实例。
func GetSingleHungry()Instance{
 return s
}

懒汉式

只有在需要使用的是由再执行单例的初始化工作

懒汉模式在多线程环境中面临挑战，需要利用互斥锁，以确保初始化过程仅执行一次。即便如此，仍存在两个线程几乎同时竞争锁的风险。假设一者成功获取锁并执行初始化，另一者则处于等待状态。当初始化完毕且锁被释放后，等待的线程随即取得锁并可能重新执行初始化，从而违背了单一初始化的原则。为解决这一问题，引入双重检查机制至关重要：即在获取锁之后，再次验证是否已完成初始化，以避免不必要的重复操作。

懒汉式编写步骤：

  1. 私有化单例类：确保单例类及其构造函数是不可导出的，防止外部直接创建实例。
  2. 延迟初始化单例变量：在类内部声明一个私有的单例变量，但不立即实例化，以实现延迟初始化。
  3. 提供公共获取方法：公开一个方法，如 GetInstance()，供外部获取单例对象的实例。
  4. 使用互斥锁保护初始化：在 GetInstance() 方法中使用互斥锁（sync.Mutex）来避免多个goroutine同时初始化单例。
  5. 双重检查锁定（Double-Check Locking）：在获取互斥锁之后，进行第二次检查，确保在锁定期间单例未被其他goroutine初始化。这样可以避免不必要的初始化操作，确保单例只被初始化一次。
  6. 初始化后释放锁：一旦单例实例化完成，释放互斥锁，允许等待的goroutine继续执行。

代码实例

// singleLazy 实现了 SingleLazyInstance 接口，保证全局仅有一个实例化的对象
var(
	l *singleLazy // 全局单例对象
	mu sync.Mutex // 互斥锁，用于线程安全的单例创建
) 

type singleLazy struct{} // 空结构体，实际的单例对象类型

// Work 打印消息表明单例对象正在工作
func (s *singleLazy) Work() {
	fmt.Println("single lazy work...")
}

// SingleLazyInstance 定义了单例模式的接口
type SingleLazyInstance interface {
	Work()
}

// newsingleLazy 实例化一个新的 singleLazy 对象
func newsingleLazy() *singleLazy{
	return &singleLazy{}
}

// GetSingleLazy 返回 singleLazy 的全局唯一实例
// 如果实例尚未创建，则创建一个新的实例并返回。
// 该方法保证了线程安全的单例模式实现。
func GetSingleLazy() SingleLazyInstance{
	if l !=nil{
		fmt.Println("single lazy is already created>>")
		return l
	}
	mu.Lock() // 加锁确保线程安全
	defer mu.Unlock() // 确保函数退出时解锁
	if l!=nil{
		fmt.Println("single lazy is created by other thread>>")
		return l // 如果已经在其他线程中创建，直接返回该实例
	}
	l=newsingleLazy() // 在此线程中首次创建单例对象	
	return l
}

golang的sync.Once 实现懒汉单例

它提供了一种机制来保证初始化操作只执行一次。这种机制特别适用于单例模式的实现，以及任何需要确保某个操作只执行一次的场景。

sync.Once 包含一个名为 Do 的方法，该方法接受一个 func() 类型的参数，即一个无参数、无返回值的函数。当 Do 方法被调用时，如果还没有进行过初始化（即 sync.Once 实例的内部状态为未初始化），它将执行提供的函数，并在执行完毕后将内部状态标记为已初始化。如果 sync.Once 实例已经初始化，Do 方法将不会再次执行提供的函数。

sync.Once 的内部实现使用了互斥锁来保证线程安全，但它的 API 设计使得开发者不需要直接处理锁的获取和释放，从而简化了代码并减少了出错的可能性。

type Once struct {
	// done indicates whether the action has been performed.
	// It is first in the struct because it is used in the hot path.
	// The hot path is inlined at every call site.
	// Placing done first allows more compact instructions on some architectures (amd64/386),
	// and fewer instructions (to calculate offset) on other architectures.
	done atomic.Uint32
	m    Mutex
}
func (o *Once) Do(f func()) {
	// Note: Here is an incorrect implementation of Do:
	//
	//	if o.done.CompareAndSwap(0, 1) {
	//		f()
	//	}
	//
	// Do guarantees that when it returns, f has finished.
	// This implementation would not implement that guarantee:
	// given two simultaneous calls, the winner of the cas would
	// call f, and the second would return immediately, without
	// waiting for the first's call to f to complete.
	// This is why the slow path falls back to a mutex, and why
	// the o.done.Store must be delayed until after f returns.

	if o.done.Load() == 0 {
		// Outlined slow-path to allow inlining of the fast-path.
		o.doSlow(f)
	}
}

func (o *Once) doSlow(f func()) {
	o.m.Lock()
	defer o.m.Unlock()
	if o.done.Load() == 0 {
		defer o.done.Store(1)
		f()
	}
}

代码实例

// 定义包级别的变量，用于存储单例实例和确保单例只被创建一次的sync.Once实例
var (
	sl   *singleInstance // 存储singleInstance单例实例
	once sync.Once       // 确保单例只被创建一次
)

// singleInstance定义了一个结构体，用于实现单例模式
type singleInstance struct{}

// Work方法实现了SingleLazyOnce接口的Work方法，用于实际的工作逻辑
func (s *singleInstance) Work() {
	fmt.Println("Doing some work...")
}

// newsingleLazyOnce函数内部返回一个新的singleInstance实例
func newsingleLazyOnce() *singleInstance {
	return &singleInstance{}
}

// SingleLazyOnce接口定义了Work方法，用于懒加载单例模式
type SingleLazyOnce interface {
	Work()
}

// GetSingleInstance函数返回singleInstance的单例实例。
// 该函数使用sync.Once确保整个应用程序中只创建一次singleInstance实例。
func GetSingleInstance() SingleLazyOnce {
	once.Do(func() {
		sl = newsingleLazyOnce() // 确保单例只被创建一次
	})
	return sl // 返回单例实例
}

总结

饿汉式单例模式：

  • 优点：在程序启动时立即创建实例，因此不存在线程安全问题，无需加锁，避免了同步控制带来的性能开销。
  • 缺点：由于实例在程序加载时即创建，即使该实例未被使用，也会导致资源的提前占用和浪费，不适用于按需创建的场景。
  • 适用场景：适合对性能要求高且实例使用频率高的场景。

懒汉式单例模式：

  • 优点：延迟实例化，仅在首次请求时创建对象，节省了内存资源，适用于实例使用频率不高的情况。
  • 缺点：需要通过加锁来确保多线程环境下的同步访问，这会带来一定的性能损耗。由于锁的粒度较大，即使在第一次创建对象后，后续访问仍需等待锁的释放。
码小白l
关注
专栏目录
[Golang] 设计模式以及单例设计模式实例实现
Jing_Hua
04-25 1644
😚一个不甘平凡的普通人，致力于为Golang社区和算法学习做出贡献，期待您的关注和认可，陪您一起学习打卡！！！😘😘😘。
golang单例模式
abcnull 的博客
06-13 923
单例模式，一种很常用的设计模式，特点是：类构造器私有化因为不能被外部构造，拥有自己的类属性，对外暴露获取实例的静态函数说白了就是返回一个实例出去，但是这个实例是只能内部构造一次，不允许外部构造非线程安全。当正在创建时，有线程来访问此时ins = nil就会再创建，单例类就会有多个实例了 懒汉加锁单例 懒汉单例线程不安全，那就加个锁呗，但加锁是要付出一些成本的 懒汉加双重锁 sync.Once单例（荐） sync.Once 是 golang 提供的方法，一旦执行一次，就不再执行 饿汉单例 线程安全，但是如果
单例模式_Golang
最新发布
weixin_45440484的博客
07-21 442
一个类只能生成一个实例，且该类能自行创建这个实例的一种模式,这个定义个人感觉可以拆的通俗一些,在项目的生命周期内,一个类生成的一个实例对象只能存在一个,调用时复用该单例对象即可,这样既节省了内存空间,也节省了创建新对象时的资源消耗,也便于资源管理.：‌在应用程序中，‌如果某些配置信息只需要读取一次，‌那么可以将这些配置信息的加载逻辑放在单例类中，‌确保配置信息只被加载一次，‌提高了性能和效率。，‌如数据库连接池、‌线程池等，‌单例模式可以确保这些对象的创建和管理更加高效。系统中只需要存在一个共享的资源。
golang 单例
qq_41661056的博客
04-27 179
package server import "sync" type ListenServer struct { } func NewListenServer() *ListenServer { return &ListenServer{} } // var listenServerInstance *ListenServer //var listenServerMutex sync.Mutex var listenServerInstanceOnceDo sync.Once // 单例
golang单例
秋天的博客
11-14 482
package singleton                                                   import (      "fmt" )                                                   type Singleton interface {      SaySomething()  }          ...
Golang-单例模式
weixin_45203607的博客
06-19 431
设计模式的重要性不用多说，也是面试时常常会被问到的问题。对于设计模式，更多的则是仁者见仁智者见智，要在实际工作中不断的积累，再进行深度的思考，才能逐渐形成的一种思维。单例模式也叫单子模式，是常用的模式之一，在它的核心结构中只包含一个被称为单例的特殊类，能够保证系统运行中一个类只创建一个实例Go语言实现单例模式的有四种方式，分别是懒汉式、饿汉式、双重检查和 sync.Once。懒汉式就是创建对象时比较懒，先不急着创建对象，在需要加载配置文件的时候再去创建；
Golang 设计模式系列1:单例模式 （Singleton Design Pattern）
weixin_36417972的博客
10-16 217
单例模式（Singleton Design Pattern） 单例模式顾名思义，会提供给用户一个对象(object)的实例(instance) ，并且保证这个实例全局唯一。 单列模式的应用场景很多，比如： 当你想用同一个链接来访问数据库的时候 当你用一个ssh 链接服务器并执行一些命令，但你不想每次都重开ssh的时候 当你想要限制访问某些资源的时候 目标 我们考虑在需要应用以下规则时使用Sin...
golang设计模式——结构模式
qq_39280718的博客
09-03 726
结构模式主要关注类和对象的组合
golang设计模式之单例模式
WLANQY的博客
01-10 198
4.测试一下func main() { s := GetExample() s.name = "第一次赋值单例模式" fmt.Println(s.name) s2 := GetExample() fmt.Println(s2.name)}懒汉模式存在线程安全问题，在第3步的时候，如果有多个线程同时调用了这个方法， 那么都会检测到instance为nil,就会创建多个对象，所以出现了饿汉模式...单例模式要实现的效果就是，对于应用单例模式的类，整个程序中只存在一个实例化对象。
Go：sync.Once 实现单例模式
weixin_34343000的博客
06-18 467
代码： package main import ( "fmt" "sync" ) type Singleton struct{} var singleton *Singleton var once sync.Once func GetSingletonObj() *Singleton { once.Do(func() { ...
GoLang设计模式之单例模式
weixin_52690231的博客
04-01 2673
GoLang设计模式之单例模式
Golang 设计模式之单例模式
liucong708302的专栏
04-30 485
单例模式定义为一个全局访问点，通过它来获取类的唯一实例。它在控制资源访问、减少系统资源消耗等方面发挥着重要作用。
Golang设计模式之单例模式
Jeanphorn的专栏
09-16 4542
1. 概述单例模式，顾名思义就是在程序的运行中只产生一个实力。在Go实现上也有多种形式。相关源代码demo在Github上，可供参考！2. 实现一、懒汉模式.这种方式实现起来特别简单，直接判断一个实力是不是为nil， 如果是，则新生成；否则返回已有的。但它和多数语言一样，只适合用在单线程。type SingleTon struct { }var instance *SingleTonfunc Get
Golang实现创建模式-单例模式(饿汉式、懒汉式、双重检查锁、单例枚举)
BXA
03-22 500
单例模式解决的问题是确保一个类只有一个实例，并提供全局访问点，以避免多个对象之间的冲突和资源浪费。这种模式通常用于管理共享资源，例如数据库连接池或线程池。 本文实现了四种不同类型的单例模式：饿汉式、懒汉式、双重检查锁和枚举 为了汇总测试，通过Main方法创建两个实例来检查它们是否是同一个对象
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值