工作笔记——小结1

计时器Ticker和Timer

1. 如果timer定时器要每隔间隔的时间执行，实现ticker的效果，使用 func (t *Timer) Reset(d Duration) bool
2. timer可以reset
   定时器Ticker：配合For循环为长久死循环定时器，开协程同时和系统休眠为定时循环用

package main

import (
	"fmt"
	"time"
)

func main() {
	go func() {
		myTicker := time.NewTicker(2 * time.Second)
		for {
			fmt.Println("Golang")
			<-myTicker.C //阻塞，形成间隔
		}
	}()
	time.Sleep(10 * time.Second)//设置定时10S
}



go func() {
	tiker := time.NewTicker(time.Second)
	for i := 0; i < 3; i++ {
		if i == 2 {
			break
		} else {
		    fmt.Println(i)
		}
		<-tiker.C
	}
 }()
fmt.Println("end")

同步组做等待用

	var wg sync.WaitGroup
	for i := 0; i < 10; i++ {//设置次数
		wg.Add(1)
		go func() {
			defer wg.Done()
			fmt.Println("golang ....")
		}()
		time.Sleep(1 * time.Second)//设置时间间隔
	}
	wg.Wait()

定时器Timer

func goTicket() {
	var myTimer *time.Timer
	var wg sync.WaitGroup
	for i := 0; i < 2; i++ {
		index := i
		wg.Add(1)
		go func() {
			defer wg.Done()
			myTimer = time.NewTimer(2 * time.Second)
			for {
				select {
				case <-myTimer.C:
					myTimer.Reset(5 * time.Second)
					fmt.Println("Reset...Reset.", time.Now().Format("2006-01-02 15:04:05"))
				}
				fmt.Println("end...", index)
			}
		}()
	}
	wg.Wait()
}

Flag的使用：

var name string
flag.StringVar(&name, "name", "everyone", "The greeting object.")
flag.Parse()
fmt.Println(name)

编译：gobuild
windows环境：GoModTest.exe  -name 123   123
不加参数输出结果：everyone

os.Args的使用

func main() {
	if SliceContainString(os.Args, "-v") {
		fmt.Printf("%v\n", os.Args[2])
	}
}

func SliceContainString(slice []string, sub string) bool {
	for _, s := range slice {
		if s == sub {
			return true
		}
	}
	return false
}

func Command(name string, arg …string) Cmd
方法返回一个Cmd， 用于执行name指定的程序(携带arg参数)
func (c *Cmd) Run() error
执行Cmd中包含的命令，阻塞直到命令执行完成
func (c *Cmd) Start() error
执行Cmd中包含的命令，该方法立即返回，并不等待命令执行完成
func (c *Cmd) Wait() error
该方法会阻塞直到Cmd中的命令执行完成，但该命令必须是被Start方法开始执行的
func (c *Cmd) Output() ([]byte, error)
执行Cmd中包含的命令，并返回标准输出的切片
func (c *Cmd) CombinedOutput() ([]byte, error)
执行Cmd中包含的命令，并返回标准输出与标准错误合并后的切片
func (c *Cmd) StdinPipe() (io.WriteCloser, error)
返回一个管道，该管道会在Cmd中的命令被启动后连接到其标准输入
func (c *Cmd) StdoutPipe() (io.ReadCloser, error)
返回一个管道，该管道会在Cmd中的命令被启动后连接到其标准输出
func (c *Cmd) StderrPipe() (io.ReadCloser, error)
返回一个管道，该管道会在Cmd中的命令被启动后连接到其标准错误

BasStoragePath = /tmp/bkdatabase/
BashNameOracleASM = hn_oracle_asm.sh
./rac.sh 执行脚本位于当前目录中

func ExecShell(storagePath, fileName, command string) (string, error) {
	logp.Info("lib ExecShell...")

	//创建路径
	err := CreateBashDir(storagePath)
	if err != nil {
		return "", fmt.Errorf("CreateBashDir error: %v\n", err)
	}

	//写入脚本
	error := CreatBashAndWrite(storagePath+fileName, command)
	if error != nil {
		return "", fmt.Errorf("CreatBashAndWrite error: %v\n", error)
	}

	//执行命令
	cmd := exec.Command("timeout", "60", storagePath+fileName)
	stdout, err := cmd.CombinedOutput()

	if err != nil {
		return "", fmt.Errorf("Execute command error: %v\n", err)
	}
	return string(stdout), nil
}

重要：cmd := exec.Command(“timeout”, “5”, command)//重要，此处可以防止脚本超时执行，卡死