Golang 设计模式

// singleton v0
type Singleton struct{}

var (
   instance *Singleton
   lock     sync.Mutex
)

func GetInstance() *Singleton {
   if instance == nil {
      lock.Lock()
      defer lock.Unlock()
      if instance == nil {
         instance = &Singleton{}
      }
   }
   return instance
}

func (o *Once) Do(f func()) {
   // Note: Here is an incorrect implementation of Do:
   //
   // if atomic.CompareAndSwapUint32(&o.done, 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 atomic.StoreUint32 must be delayed until after f returns.

   if atomic.LoadUint32(&o.done) == 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 == 0 {
      defer atomic.StoreUint32(&o.done, 1)
      f()
   }
}

package main

import (
   "log"
   "net/http"
)

// Handler defination
type Handler func(http.ResponseWriter, *http.Request)

// Middleware defination
type Middleware func(Handler) Handler

// Chain multi middleware to one
func Chain(mws ...Middleware) Middleware {
    return func(handler Handler) Handler {
        for _, mw := range mws {
            handler = mw(handler)
        }
        return handler
    }
}

// Logging middleware
func Logging(handler Handler) Handler {
    return func(w http.ResponseWriter, r *http.Request) {
        log.Printf("[access] %s", r.URL.String())
        handler(w, r)
    }
}

func Hello(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("hello"))
}
func Echo(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("echo"))
}

func main() {
    http.HandleFunc("/hello", Logging(Hello))
    http.HandleFunc("/echo", Logging(Echo))

    log.Panic(http.ListenAndServe(":8080", nil))
}

package main

type Config struct {
    ConnectTimeout int
    ReadTimeout    int
    MaxRetry       int
}

type Option func(*Config)

func WithConnectTimeout(timeout int) Option {
    return func(config *Config) {
        config.ConnectTimeout = timeout
    }
}

func WithReadTimeoutt(timeout int) Option {
    return func(config *Config) {
        config.ReadTimeout = timeout
    }
}

func WithMaxRetry(maxRetry int) Option {
    return func(config *Config) {
        config.MaxRetry = maxRetry
    }
}

type Client struct {
    c *Config
}

func NewClient(opts ...Option) *Client {
    config := &Config{
        ConnectTimeout: 1000,
        ReadTimeout:    2000,
        MaxRetry:       3,
    }
    for _, opt := range opts {
        opt(config)
    }
    client := &Client{
        c: config,
    }
    return client
}

func main() {
    _ = NewClient(
        WithConnectTimeout(500),
        WithMaxRetry(5),
    )
}

func Merge(channels ...<-chan int) <-chan int {
    var wg sync.WaitGroup

    out := make(chan int)

    // Start an send goroutine for each input channel in channels. send
    // copies values from c to out until c is closed, then calls wg.Done.
    send := func(c <-chan int) {
        for n := range c {
            out <- n
        }
        wg.Done()
    }

    wg.Add(len(channels))
    for _, c := range channels {
        go send(c)
    }

    // Start a goroutine to close out once all the send goroutines are
    // done.  This must start after the wg.Add call.
    go func() {
        wg.Wait()
        close(out)
    }()
    return out
}

type Executor interface {
    Exec(string) (string, error)
}

type ExecutorFunc func(string) (string, error)

// Function to interface object
func (f ExecutorFunc) Exec(s string) (string, error) {
    return f(s)
}

func NeedExecutor(executor Executor) {
    fmt.Println(executor.Exec("abc"))
}
func Handle(s string) (string, error) {
    return s + "handled", nil
}
func main() {
    NeedExecutor(ExecutorFunc(Handle))
}

package main

import (
   "context"
   "fmt"
   "sync/atomic"
   "time"
)

var idCounter uint64

func Echo(ctx context.Context, message string) {
    atomic.AddUint64(&idCounter, 1)
    fmt.Printf("this is plugin1: cnt:%d msg=%s\n", idCounter , message)
}

package main

import (
    "context"
    "os"
    "plugin"
    "time"
)

func main() {
    successDemo()
}

func successDemo() {
    //加载plugin1
    echoPlugin, err := plugin.Open("/xxxxx/go_plugin_demo/plugins/plugin1/plugin.so")
    if err != nil {
        os.Exit(0)
    }

    go func() {
        time.Sleep(5* time.Second)
        // 加载plugin2
        echoPlugin, err = plugin.Open("/xxxxx/go_plugin_demo/plugins/plugin2/plugin.so")
        if err != nil {
            os.Exit(0)
        }
    }()

    for {
        echoSymbol, _ := echoPlugin.Lookup("Echo")
        ctx := context.Background()
        echoSymbol.(func(ctx context.Context, message string))(ctx, "hello")
        time.Sleep(time.Second)
    }
}