单例模式（Singleton Pattern）：确保一个类只有一个实例，并提供全局访问点。在Go语言中，使用sync.Once保证只有一个实例被创建。
package singleton
import (
“sync”
)
type Singleton struct {}
var instance *Singleton
var once sync.Once
func GetInstance() *Singleton {
once.Do(func() {
instance = &Singleton{}
})
return instance
}
工厂模式（Factory Pattern）：定义一个创建对象的接口，让子类决定实例化哪个类。在Go语言中，可以使用interface来定义对象的创建方法，然后具体的工厂实现接口方法。
package factory
type Product interface {
GetName() string
}
type ConcreteProduct struct {}
func (p *ConcreteProduct) GetName() string {
return “ConcreteProduct”
}
type Factory interface {
CreateProduct() Product
}
type ConcreteFactory struct {}
func (f *ConcreteFactory) CreateProduct() Product {
return &ConcreteProduct{}
}
观察者模式（Observer Pattern）：定义一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。在Go语言中，可以使用channel实现观察者模式。
package observer
type Observer interface {
Update()
}
type Subject interface {
Attach(observer Observer)
Detach(observer Observer)
Notify()
}
type ConcreteObserver struct {}
func (o *ConcreteObserver) Update() {}
type ConcreteSubject struct {
observers []Observer
}
func (s *ConcreteSubject) Attach(observer Observer) {
s.observers = append(s.observers, observer)
}
func (s *ConcreteSubject) Detach(observer Observer) {
for i, o := range s.observers {
if o == observer {
s.observers = append(s.observers[:i], s.observers[i+1:]…)
break
}
}
}
func (s *ConcreteSubject) Notify() {
for _, o := range s.observers {
o.Update()
}
}
适配器模式（Adapter Pattern）：将一个类的接口转换成客户希望的另一个接口。在Go语言中，可以使用interface来实现适配器模式。
package adapter
type Target interface {
Request()
}
type Adaptee interface {
SpecificRequest()
}
type Adapter struct {
adaptee Adaptee
}
func (a *Adapter) Request() {
a.adaptee.SpecificRequest()
}
type ConcreteAdaptee struct {}
func (a *ConcreteAdaptee) SpecificRequest() {}
策略模式（Strategy Pattern）：定义一系列算法，把它们封装起来，并且使它们可以相互替换。在Go语言中，可以使用函数作为参数传递实现策略模式。
package strategy
type Strategy func()
type Context struct {
strategy Strategy
}
func (c *Context) SetStrategy
模板方法模式（Template Method Pattern）：定义一个操作中的算法框架，将一些步骤延迟到子类中。在Go语言中，可以使用接口和组合实现模板方法模式。
责任链模式（Chain of Responsibility Pattern）：将请求的发送者和接收者解耦，使多个对象都有机会处理这个请求。在Go语言中，可以使用链表或者切片实现责任链模式。