go语言常用的设计模式，及实现代码

1. 单例模式（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
}

2. 工厂模式（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{}
}

3. 观察者模式（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()
    }
}

4. 适配器模式（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() {}

5. 策略模式（Strategy Pattern）：定义一系列算法，把它们封装起来，并且使它们可以相互替换。在Go语言中，可以使用函数作为参数传递实现策略模式。

package strategy

type Strategy func()

type Context struct {
    strategy Strategy
}

func (c *Context) SetStrategy

6. 模板方法模式（Template Method Pattern）：定义一个操作中的算法框架，将一些步骤延迟到子类中。在Go语言中，可以使用接口和组合实现模板方法模式。

7. 责任链模式（Chain of Responsibility Pattern）：将请求的发送者和接收者解耦，使多个对象都有机会处理这个请求。在Go语言中，可以使用链表或者切片实现责任链模式。