go - 定时器、进程内存信息、redis分布式锁

1.定时器 

/*通过NewTimer和NewTicker分别实现定时器*/
package main

import (
	"fmt"
	"time"
)

func main() {
	/**Timer的数据结构，有一个管道C，指定时间，向管道C中存入数据
	type Timer struct{
		C<-chan Time
		r runtimeTimer
	}*/
	fmt.Println(time.Now().UTC(), "starting....")
	timer := time.NewTimer(time.Second * 2) //定时2s
	ticker := time.NewTicker(time.Second * 5)
	bools := make(chan bool)
	go func(t1 *time.Timer, t2 *time.Ticker) { //t *time.Timer--形参
		//defer--当前函数执行完之后才执行
		defer t1.Stop()
		defer t2.Stop()
		for {
			select {   //多个同时满足，任选其一执行。
			case <-t1.C: //2s时间到，timer管道C中有值
				fmt.Println(time.Now().UTC(), "timer-2s已到")
				t1.Reset(time.Second * 2)
			case stop := <-bools:
				if stop {
					fmt.Println("stop")
					return
				}
			case <-t2.C:
				fmt.Println(time.Now().UTC(), "ticker-5s已到\n")
				t2.Reset(time.Second * 5)
			}
		}
	}(timer, ticker) //将timer与ticker作为实参传入
	time.Sleep(11 * time.Second)
	bools <- true //true存入管道bools时，select循环中stop会出现值，所以退出select循环
	close(bools)
	time.Sleep(1 * time.Second)
}

2.当前进程内存

package main

import (
	"log"
	"os"
	"os/exec"
	"runtime"
	"strconv"
)

func processId() {
	pid := os.Getpid()
	sysType := runtime.GOOS
	var command *exec.Cmd
	if "linux" == sysType {
		command = exec.Command("ps", "-p", strconv.Itoa(pid), "-v")

	}else if "windows" == sysType{
		command = exec.Command("tasklist", "|findstr", strconv.Itoa(pid))
	}
	output, err := command.Output()
	if err != nil {
		panic(err)
	}
	log.Printf("current process info:\n%s", string(output))
}
func main() {
	processId()
}

3.redis分布式锁

参考地址： github.com/bigwhite/experiments/redis-cluster-distributed-lock

//参考：github.com/bigwhite/experiments/redis-cluster-distributed-lock
package main

import (
	"context"
	"log"
	"os"
	"os/signal"
	"strings"
	"sync"
	"sync/atomic"
	"syscall"
	"time"

	goredislib "github.com/go-redis/redis/v8"
	"github.com/go-redsync/redsync/v4"
	"github.com/go-redsync/redsync/v4/redis/goredis/v8"
	"github.com/satori/go.uuid"
)

const (
	redisClusterMasters      = "localhost:6379,localhost:6380,localhost:6381"
)

var (
	isLeader  int64
	m         atomic.Value
	mutexName = "prometheus-distributed-lock"
	suuid     string
)

func init() {
	suuid = uuid.NewV4().String()
}
//uuid，用于生成redis分布式锁的值
func fuuid() (string,error) {
	return suuid,nil
}

func GetIsLeader() int64 {
	return isLeader
}

func getRedisVal(client *goredislib.ClusterClient) string {
	ctx := context.Background()
	return client.Get(ctx, mutexName).Val()
}

func tryToBecomeLeader(client *goredislib.ClusterClient) (bool, func() (bool, error), error) {
	pool := goredis.NewPool(client)
	rs := redsync.New(pool)

	/**NewMutex中锁value:就是给的一个随机值
		_, err := rand.Read(b)
		........
		return base64.StdEncoding.EncodeToString(b), nil
	*/
	valueFunc := redsync.WithGenValueFunc(fuuid) //将uuid作为redis的value带到分布式锁中执行
	expiry := redsync.WithExpiry(30 * time.Second) //设置redis锁过期时间
	mutex := rs.NewMutex(mutexName,valueFunc,expiry)
	if err := mutex.Lock(); err != nil {
		return false, nil, err
	}
	return true, func() (bool, error) {
        lockVal := getRedisVal(client)
		if lockVal == suuid {
			return mutex.Unlock()//解锁，也就是删除锁
		/*删除锁unlock会调用以下脚本：var deleteScript = redis.NewScript(1, `
			if redis.call("GET", KEYS[1]) == ARGV[1] then
				return redis.call("DEL", KEYS[1])
			else
				return 0
			end
		`)*/
		}else {
			log.Printf("redis lock-%s doesn't belong to itself, fail to lock!",lockVal)
			return false, nil
		}
		
	}, nil
}

func doElectionAndMaintainTheStatus(c *goredislib.ClusterClient, quit <-chan struct{}) {
	ticker := time.NewTicker(time.Second * 5) //5s定时任务，刷新redis分布式锁过期时间
	var err error
	var ok bool
	var cf func() (bool, error) //声明了一个函数cf，用于传入tryToBecomeLeader

	for {
		select {
		case <-ticker.C:
			if atomic.LoadInt64(&isLeader) == 0 { //原子的读取isLeader地址处的代码
				ok, cf, err = tryToBecomeLeader(c)
				if ok {
                    //锁成功后的逻辑，如果需要加入其它逻辑，可以直接拿到isLeader==1时，执行锁住的代码逻辑
					log.Printf("prog-%s become leader successfully\n", suuid)
					atomic.StoreInt64(&isLeader, 1) //原子的存储
					defer cf()  /*延迟执行tryToBecomeLeader中的代码：
								return true, func() (bool, error) {
								return mutex.Unlock()
								}, nil*/
				}
				if !ok || err != nil {
					log.Printf("prog-%s try to become leader failed: %s\n", suuid, err)
				}
			} else {
				log.Printf("prog-%s is the leader\n", suuid)
				// update the lock live time and maintain the leader status
				c.Expire(context.Background(), mutexName, 30*time.Second)
			}
		case <-quit:
			return
		}
	}
}


func main() {
	var wg sync.WaitGroup
	wg.Add(1)
	var quit = make(chan struct{}) //空结构体，读取close的channel，返回零
	//log.Println(<-quit)
	client := goredislib.NewClusterClient(&goredislib.ClusterOptions{
		Addrs: strings.Split(redisClusterMasters, ","), Password: "994a02c8_3e98_498c_99fa_77f371df0c9c"})
	defer client.Close()

	go func() {
		doElectionAndMaintainTheStatus(client, quit)
		wg.Done()
	}()

	c := make(chan os.Signal, 1)                      //可放入1个信号
	signal.Notify(c, syscall.SIGINT, syscall.SIGTERM) //监听中断信号ctrl+c，管道c接受信号，syscall.SIGINT, syscall.SIGTERM为要监听的信号（不设置-监听所有信号）
	// block until a signal is received阻塞直到接收到中断信号
	s := <-c
	close(quit)  //quit通道会返回0，doElectionAndMaintainTheStatus中的select检测到quit有值，则会停止
	log.Printf("recv exit signal...", s)
	wg.Wait()//等待go func线程结束
	log.Printf("program exit ok")
}