go: Semaphore Pattern

博客园 - ®Geovin Du Dream Park™

go: Functional Options Pattern go:Timing Functions Pattern python: Timing Functions Pattern go: Steady-State Pattern python: Steady-State Pattern go: Handshaking Pattern python: Handshaking Pattern go: Fail-Fast Pattern python: Fail-Fast Pattern I go: Deadline Pattern python: Deadline Pattern go: Circuit-Breaker Pattern python: Circuit-Breaker Pattern go: Bulkheads Pattern python: Bulkheads Pattern go: Push & Pull Pattern python: Push & Pull Pattern python: Publish/Subscribe Pattern II go: Publish/Subscribe Pattern python: Publish/Subscribe Pattern go: Futures & Promises Pattern python: Futures & Promises Pattern go: Worker Pool Pattern go：Pipeline Pattern python: Worker Pool Pattern python: Pipeline Pattern go: Fan-Out Pattern python: Fan-Out Pattern go: Fan-In Pattern python: Fan-In Pattern Fan-In

®Geovin Du Dream Park™ · 2026-05-19 · via 博客园 - ®Geovin Du Dream Park™

项目结构：

/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：企业级信号量模式 Semaphore Pattern
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/5/19 21:40
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : logger.go
*/
package common

import "log"

// Logger 标准化日志接口（可替换为zap/logrus）
type Logger interface {
	Infof(format string, args ...any)
	Errorf(format string, args ...any)
}

// DefaultLogger 默认实现
type DefaultLogger struct{}

func NewDefaultLogger() Logger {
	return &DefaultLogger{}
}

func (l *DefaultLogger) Infof(format string, args ...any) {
	log.Printf("[INFO] "+format, args...)
}

func (l *DefaultLogger) Errorf(format string, args ...any) {
	log.Printf("[ERROR] "+format, args...)
}


/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：企业级信号量模式 Semaphore Pattern
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/5/19 21:40
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : config.go
*/
package config

// FactoryConfig 工厂全局配置（所有公共资源上限可配置）
type FactoryConfig struct {
	MeltConcurrency    int // 黄金熔炉并发数
	CutConcurrency     int // 钻石切割台并发数
	InlayConcurrency   int // 珠宝镶嵌台并发数
	QualityConcurrency int // 质检台并发数
	VIPConcurrency     int // VIP定制工坊并发数
}

// LoadDefaultConfig 加载默认配置（可对接Nacos/Apollo/Env）
func LoadDefaultConfig() *FactoryConfig {
	return &FactoryConfig{
		MeltConcurrency:    2,
		CutConcurrency:     3,
		InlayConcurrency:   1,
		QualityConcurrency: 2,
		VIPConcurrency:     1,
	}
}

/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：业级信号量模式 Semaphore Pattern
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/5/19 21:41
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : order.go
*/
package model

// OrderType 订单工序类型
type OrderType string

const (
	OrderTypeMelt    OrderType = "熔炼"
	OrderTypeCut     OrderType = "切割"
	OrderTypeInlay   OrderType = "镶嵌"
	OrderTypeQuality OrderType = "质检"
	OrderTypeVIP     OrderType = "VIP定制"
)

// Priority 优先级
type Priority string

const (
	PriorityNormal Priority = "普通"
	PriorityVIP    Priority = "VIP"
)

// JewelryOrder 珠宝订单（纯数据，无逻辑）
type JewelryOrder struct {
	OrderID  int
	Type     OrderType
	Priority Priority
}

/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：业级信号量模式 Semaphore Pattern
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/5/19 21:41
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : semaphore.go
*/
package semaphore

// Semaphore 通用信号量接口（完全可扩展：可替换为分布式信号量）
type Semaphore interface {
	Acquire()
	Release()
}

// ChanSemaphore 基于channel的内存信号量（Go标准实现）
type ChanSemaphore struct {
	sem chan struct{}
}

func NewChanSemaphore(capacity int) Semaphore {
	return &ChanSemaphore{
		sem: make(chan struct{}, capacity),
	}
}

func (s *ChanSemaphore) Acquire() {
	s.sem <- struct{}{}
}

func (s *ChanSemaphore) Release() {
	<-s.sem
}

/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：业级信号量模式 Semaphore Pattern
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/5/19 21:45
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : cut.go
*/
package service

import (
	"godesginpattern/semaphore/common"
	"godesginpattern/semaphore/model"
	"godesginpattern/semaphore/semaphore"
	"time"
)

// 切割服务
type CutService struct {
	sem    semaphore.Semaphore
	logger common.Logger
}

func NewCutService(sem semaphore.Semaphore, logger common.Logger) *CutService {
	return &CutService{sem: sem, logger: logger}
}

func (s *CutService) Process(order any) {
	o := order.(model.JewelryOrder)
	s.sem.Acquire()
	defer s.sem.Release()

	s.logger.Infof("[切割] 订单%d 开始钻石切割 | 占用切割台", o.OrderID)
	time.Sleep(1 * time.Second)
	s.logger.Infof("[切割] 订单%d 切割完成 ✅", o.OrderID)
}



/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：业级信号量模式 Semaphore Pattern
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/5/19 21:46
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : inlay.go
*/
package service

import (
	"godesginpattern/semaphore/common"
	"godesginpattern/semaphore/model"
	"godesginpattern/semaphore/semaphore"
	"time"
)

// 镶嵌服务
type InlayService struct {
	sem    semaphore.Semaphore
	logger common.Logger
}

func NewInlayService(sem semaphore.Semaphore, logger common.Logger) *InlayService {
	return &InlayService{sem: sem, logger: logger}
}

func (s *InlayService) Process(order any) {
	o := order.(model.JewelryOrder)
	s.sem.Acquire()
	defer s.sem.Release()

	s.logger.Infof("[镶嵌] 订单%d 开始精密镶嵌 | 独占设备", o.OrderID)
	time.Sleep(2 * time.Second)
	s.logger.Infof("[镶嵌] 订单%d 镶嵌完成 ✅", o.OrderID)
}


/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：业级信号量模式 Semaphore Pattern
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/5/19 21:44
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : melt.go
*/
package service

import (
	"godesginpattern/semaphore/common"
	"godesginpattern/semaphore/model"
	"godesginpattern/semaphore/semaphore"
	"time"
)

// 炼服务：单一职责
type MeltService struct {
	sem    semaphore.Semaphore
	logger common.Logger
}

func NewMeltService(sem semaphore.Semaphore, logger common.Logger) *MeltService {
	return &MeltService{sem: sem, logger: logger}
}

func (s *MeltService) Process(order any) {
	o := order.(model.JewelryOrder)
	s.sem.Acquire()
	defer s.sem.Release()

	s.logger.Infof("[熔炼] 订单%d 开始黄金熔炼 | 占用熔炉资源", o.OrderID)
	time.Sleep(1 * time.Second)
	s.logger.Infof("[熔炼] 订单%d 熔炼完成 ✅", o.OrderID)
}


/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：业级信号量模式 Semaphore Pattern
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/5/19 21:47
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : quality.go
*/
package service

import (
	"godesginpattern/semaphore/common"
	"godesginpattern/semaphore/model"
	"godesginpattern/semaphore/semaphore"
	"time"
)

type QualityService struct {
	sem    semaphore.Semaphore
	logger common.Logger
}

func NewQualityService(sem semaphore.Semaphore, logger common.Logger) *QualityService {
	return &QualityService{sem: sem, logger: logger}
}

func (s *QualityService) Process(order any) {
	o := order.(model.JewelryOrder)
	s.sem.Acquire()
	defer s.sem.Release()

	s.logger.Infof("[质检] 订单%d 开始品质检测", o.OrderID)
	time.Sleep(1 * time.Second)
	s.logger.Infof("[质检] 订单%d 检测通过 ✅", o.OrderID)
}


/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：业级信号量模式 Semaphore Pattern
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/5/19 21:48
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : vip.go
*/
package service

import (
	"godesginpattern/semaphore/common"
	"godesginpattern/semaphore/model"
	"godesginpattern/semaphore/semaphore"
	"time"
)

// VIP 定制服务
type VIPService struct {
	sem    semaphore.Semaphore
	logger common.Logger
}

func NewVIPService(sem semaphore.Semaphore, logger common.Logger) *VIPService {
	return &VIPService{sem: sem, logger: logger}
}

func (s *VIPService) Process(order any) {
	o := order.(model.JewelryOrder)
	s.sem.Acquire()
	defer s.sem.Release()

	s.logger.Infof("[VIP定制] 订单%d 开始专属工坊制作", o.OrderID)
	time.Sleep(3 * time.Second)
	s.logger.Infof("[VIP定制] 订单%d 定制完成 ✨", o.OrderID)
}

/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：业级信号量模式 Semaphore Pattern
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/5/19 21:42
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : factory.go
*/
package service

import (
	"godesginpattern/semaphore/common"
	"godesginpattern/semaphore/config"
	"godesginpattern/semaphore/semaphore"
)

// Service 所有工序服务统一接口
type Service interface {
	Process(order any)
}

// NewServiceFactory 创建所有业务服务（依赖注入：配置+信号量+日志）
func NewServiceFactory(
	cfg *config.FactoryConfig,
	logger common.Logger,
) map[string]Service {
	return map[string]Service{
		"熔炼":    NewMeltService(semaphore.NewChanSemaphore(cfg.MeltConcurrency), logger),
		"切割":    NewCutService(semaphore.NewChanSemaphore(cfg.CutConcurrency), logger),
		"镶嵌":    NewInlayService(semaphore.NewChanSemaphore(cfg.InlayConcurrency), logger),
		"质检":    NewQualityService(semaphore.NewChanSemaphore(cfg.QualityConcurrency), logger),
		"VIP定制": NewVIPService(semaphore.NewChanSemaphore(cfg.VIPConcurrency), logger),
	}
}

/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：业级信号量模式 Semaphore Pattern
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/5/19 21:49
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : scheduler.go
*/
package scheduler

import (
	"godesginpattern/semaphore/common"
	"godesginpattern/semaphore/model"
	"godesginpattern/semaphore/service"
	"sync"
)

// OrderScheduler 订单调度器（编排+并发控制）
type OrderScheduler struct {
	serviceMap map[string]service.Service
	logger     common.Logger
}

func NewOrderScheduler(
	serviceMap map[string]service.Service,
	logger common.Logger,
) *OrderScheduler {
	return &OrderScheduler{
		serviceMap: serviceMap,
		logger:     logger,
	}
}

// Schedule 并发调度订单
func (s *OrderScheduler) Schedule(orders []model.JewelryOrder) {
	s.logger.Infof("========== 珠宝工厂开始生产，总订单数：%d ==========", len(orders))
	var wg sync.WaitGroup

	for _, ord := range orders {
		wg.Add(1)
		go func(order model.JewelryOrder) {
			defer wg.Done()
			svc, exists := s.serviceMap[string(order.Type)]
			if !exists {
				s.logger.Errorf("未知工序类型：%s", order.Type)
				return
			}
			svc.Process(order)
		}(ord)
	}

	wg.Wait()
	s.logger.Infof("========== 所有订单生产完成 ==========")
}

调用：

/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：业级信号量模式 Semaphore Pattern
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/5/19 21:50
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : semaphorebll.go
Semaphore/
├── config/              # 配置定义
│   └── config.go
├──             # 内部业务（禁止外部引用）
│   ├── semaphore/       # 通用信号量组件（可复用）
│   │   └── semaphore.go
│   ├── model/           # 数据模型
│   │   └── order.go
│   ├── service/         # 业务逻辑层（核心工序）
│   │   ├── factory.go   # 服务注册/依赖注入
│   │   ├── melt.go
│   │   ├── cut.go
│   │   ├── inlay.go
│   │   ├── quality.go
│   │   └── vip.go
│   └── scheduler/       # 调度/编排层
│       └── scheduler.go
├── pkg/                 # 公共工具（可跨项目复用）
│   └── logger.go
├── go.mod
└── main.go              # 入口（极简）
*/
package bll

import (
	"godesginpattern/semaphore/common"
	"godesginpattern/semaphore/config"
	"godesginpattern/semaphore/model"
	"godesginpattern/semaphore/scheduler"
	"godesginpattern/semaphore/service"
)

func SemaphoreMain() {

	// 1. 初始化基础组件
	logger := common.NewDefaultLogger()
	cfg := config.LoadDefaultConfig()

	// 2. 依赖注入：创建所有业务服务
	serviceMap := service.NewServiceFactory(cfg, logger)

	// 3. 创建调度器
	orderScheduler := scheduler.NewOrderScheduler(serviceMap, logger)

	// 4. 构造订单数据
	orders := []model.JewelryOrder{
		{1, model.OrderTypeMelt, model.PriorityNormal},
		{2, model.OrderTypeMelt, model.PriorityNormal},
		{3, model.OrderTypeMelt, model.PriorityNormal},
		{4, model.OrderTypeCut, model.PriorityNormal},
		{5, model.OrderTypeCut, model.PriorityNormal},
		{6, model.OrderTypeCut, model.PriorityNormal},
		{7, model.OrderTypeCut, model.PriorityNormal},
		{8, model.OrderTypeInlay, model.PriorityNormal},
		{9, model.OrderTypeInlay, model.PriorityNormal},
		{10, model.OrderTypeQuality, model.PriorityNormal},
		{11, model.OrderTypeQuality, model.PriorityNormal},
		{12, model.OrderTypeQuality, model.PriorityNormal},
		{13, model.OrderTypeVIP, model.PriorityVIP},
		{14, model.OrderTypeVIP, model.PriorityVIP},
	}

	// 5. 启动生产
	orderScheduler.Schedule(orders)

}

输出：

哲学管理(学)人生, 文学艺术生活, 自动(计算机学)物理(学)工作, 生物(学)化学逆境, 历史(学)测绘(学)时间, 经济(学)数学金钱(理财), 心理(学)医学情绪, 诗词美容情感, 美学建筑(学)家园, 解构建构(分析)整合学习, 智商情商(IQ、EQ)运筹(学)生存.---Geovin Du(涂聚文）

此内容由惯性聚合(RSS阅读器)自动聚合整理，仅供阅读参考。原文来自 — 版权归原作者所有。

推荐订阅源

博客园 - ®Geovin Du Dream Park™