使用Golang利用ectd实现一个分布式锁

lbdbzj110

package etcdsync　　import (
　　"fmt"
　　"io"
　　"os"
　　"sync"
　　"time"
　　"github.com/coreos/etcd/client"
　　"github.com/coreos/etcd/Godeps/_workspace/src/golang.org/x/net/context"
　　)
　　const (
　　defaultTTL = 60
　　defaultTry = 3
　　deleteAction = "delete"
　　expireAction = "expire"
　　)
　　// A Mutex is a mutual exclusion lock which is distributed across a cluster.
　　type Mutex struct {
　　key    string

　　id     string // The>　　client client.Client
　　kapi   client.KeysAPI
　　ctx    context.Context
　　ttl    time.Duration
　　mutex  *sync.Mutex
　　logger io.Writer
　　}
　　// New creates a Mutex with the given key which must be the same
　　// across the cluster nodes.
　　// machines are the ectd cluster addresses
　　func New(key string, ttl int, machines []string) *Mutex {
　　cfg := client.Config{
　　Endpoints:               machines,
　　Transport:               client.DefaultTransport,
　　HeaderTimeoutPerRequest: time.Second,
　　}
　　c, err := client.New(cfg)
　　if err != nil {
　　return nil
　　}
　　hostname, err := os.Hostname()
　　if err != nil {
　　return nil
　　}
　　if len(key) == 0 || len(machines) == 0 {
　　return nil
　　}
　　if key[0] != '/' {
　　key = "/" + key
　　}
　　if ttl < 1 {
　　ttl = defaultTTL
　　}
　　return &Mutex{
　　key:    key,
　　id:     fmt.Sprintf("%v-%v-%v", hostname, os.Getpid(), time.Now().Format("20060102-15:04:05.999999999")),
　　client: c,
　　kapi:   client.NewKeysAPI(c),
　　ctx: context.TODO(),
　　ttl: time.Second * time.Duration(ttl),
　　mutex:  new(sync.Mutex),
　　}
　　}
　　// Lock locks m.
　　// If the lock is already in use, the calling goroutine
　　// blocks until the mutex is available.
　　func (m *Mutex) Lock() (err error) {
　　m.mutex.Lock()
　　for try := 1; try