项目结构：
Go
/*
# 版权所有 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,
}
}
Go
/*
# 版权所有 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
}
Go
/*
# 版权所有 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
}
Go
/*
# 版权所有 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),
}
}
Go
/*
# 版权所有 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("========== 所有订单生产完成 ==========")
}调用：
Go
/*
# 版权所有 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)
}输出：
