模块使用

执行系统shell命令

• 使用os/exec模块

package main
import (
 "fmt"
 "os/exec"
)
func main() {
 var (
 cmd *exec.Cmd
 err error
 )
 cmd = exec.Command("/bin/bash","-c","echo hello")
 err = cmd.Run()
 if err != nil {
 fmt.Println(err)
 }
 fmt.Println(err)
}

• 获取命令执行的返回结果

package main
import (
 "fmt"
 "os/exec"
)
func main() {
 var (
 cmd *exec.Cmd
 output []byte
 err error
 )
 //生成cmd
 cmd = exec.Command("/bin/bash","-c","sleep 1;ls -l ~/")
 if output,err = cmd.CombinedOutput();err != nil {
 fmt.Printf("cmd return faild,err:%v\n",err)
 return
 }
 //打印返回结果
 fmt.Printf("%s\n",string(output))
}

• 多线程

package main
import (
 "context"
 "fmt"
 "os/exec"
 "time"
)
type result struct {
 err error
 output []byte
}
func main() {
 var (
 cmd *exec.Cmd
 ctx context.Context
 cancelFunc context.CancelFunc
 resultChan chan *result
 res *result
 )
 resultChan = make(chan *result,1000) //创建一个结果队列
 ctx,cancelFunc = context.WithCancel(context.TODO())
 go func() {
 var (
 output []byte
 err error
 )
 cmd = exec.CommandContext(ctx,"/bin/bash","-c","sleep 2;echo hello")
 //执行任务,捕获输出
 output,err = cmd.CombinedOutput()
 //把输出结果输出给main协程
 resultChan <- &result{
 err: err,
 output: output,
 }
 }()
 //1秒取消上下文
 time.Sleep(time.Second*3)
 //取消上下文
 cancelFunc()
 //在main协程里等待子协程的退出,并打印任务执行的结果
 res = <- resultChan
 fmt.Println(res.err,string(res.output))
 //fmt.Printf("err=%v,res=%s\n",res.err,string(res.output))
}

cron模块的使用

• 执行单个任务

package main
import (
 "fmt"
 "github.com/gorhill/cronexpr"
 "time"
)
func main() {
 var (
 expr *cronexpr.Expression
 err error
 )
 //每分钟执行一次
 /*
 if expr,err = cronexpr.Parse("* * * * *");err != nil {
 fmt.Println(err)
 return
 }
 */
 //每五秒执行一次,支持到年的配置
 if expr,err = cronexpr.Parse("*/5 * * * * * *");err != nil {
 fmt.Println(err)
 return
 }
 //获取当前时间
 now := time.Now()
 //下次执行时间
 nextTime := expr.Next(now)
 //等待这个定时器超时
 time.AfterFunc(nextTime.Sub(now), func() {
 fmt.Println("被调度了:",nextTime)
 })
 time.Sleep(time.Second*5)
}

• 执行多个任务

package main
import (
 "fmt"
 "github.com/gorhill/cronexpr"
 "time"
)
type CronJob struct {
 expr *cronexpr.Expression
 nextTime time.Time
}
func main() {
 //需要一个调度协程,定时检查所有的cron任务,谁过期执行谁
 var (
 cronJob *CronJob
 expr *cronexpr.Expression
 now time.Time
 scheduleTable map[string]*CronJob
 )
 scheduleTable = make(map[string]*CronJob) //初始化调度表
 //获取当前时间
 now = time.Now()
 // 1.定义两个cron
 expr = cronexpr.MustParse("*/5 * * * * * *")
 cronJob = &CronJob{
 expr: expr,
 nextTime: expr.Next(now),
 }
 //将任务1注册到调度表
 scheduleTable["job1"] = cronJob
 // 2.定义两个cron
 expr = cronexpr.MustParse("*/5 * * * * * *")
 cronJob = &CronJob{
 expr: expr,
 nextTime: expr.Next(now),
 }
 //将任务1注册到调度表
 scheduleTable["job2"] = cronJob
 //启动一个调度协程
 go func() {
 var(
 jobName string
 cronJob *CronJob
 now time.Time
 )
 //定期检查调度表
 for {
 now = time.Now()
 for jobName,cronJob = range scheduleTable {
 //判断是否过期
 if cronJob.nextTime.Before(now) || cronJob.nextTime.Equal(now) {
 //启动一个协程,执行这个任务
 go func(jobName string) {
 fmt.Println("执行:",jobName)
 }(jobName)
 }
 //计算下一次的调度时间
 cronJob.nextTime = cronJob.expr.Next(now)
 fmt.Println(jobName,"下次执行的时间:",cronJob.nextTime)
 }
 }
 //睡眠100毫秒,进入下一次循环
 select {
 case <- time.NewTimer(100*time.Millisecond).C: //将在100毫秒可读,返回
 }
 }()
 time.Sleep(100*time.Second)
}

etcd的使用

• 与etcd建立连接

package main
import (
 "fmt"
 "github.com/coreos/etcd/clientv3"
 "time"
)
func main() {
 var (
 config clientv3.Config
 client *clientv3.Client
 err error
 )
 //客户端配置
 config = clientv3.Config{
 Endpoints: []string{"192.168.56.11:2379"},
 DialTimeout: 5*time.Second,
 }
 //建立连接
 if client,err = clientv3.New(config);err != nil {
 fmt.Println(err)
 return
 }
 client = client
}

• 插入键值对

package main
import (
 "context"
 "fmt"
 "github.com/coreos/etcd/clientv3"
 "time"
)
func main() {
 var (
 config clientv3.Config
 client *clientv3.Client
 err error
 kv clientv3.KV
 putResp *clientv3.PutResponse
 )
 //建立连接
 config = clientv3.Config{
 Endpoints: []string{"192.168.56.11:2379"},
 DialTimeout: 5*time.Second,
 }
 if client,err = clientv3.New(config);err!=nil {
 fmt.Println(err)
 return
 }
 //读写etcd的键值对
 kv = clientv3.NewKV(client)
 //kv.Put(ctx context.Context())
 if putResp,err = kv.Put(context.TODO(),"/cron/jobs/job1","hello",clientv3.WithPrefix());err != nil {
 fmt.Println(err)
 return
 }else {
 fmt.Println(putResp.Header.Revision)
 if putResp.PrevKv != nil {
 fmt.Println("PrevValue:",string(putResp.PrevKv.Value))
 }
 }
}

• 读写etcd键值对

package main
import (
 "context"
 "fmt"
 "github.com/coreos/etcd/clientv3"
 "time"
)
func main() {
 var (
 config clientv3.Config
 client *clientv3.Client
 err error
 kv clientv3.KV
 getResp *clientv3.GetResponse
 )
 //建立连接
 config = clientv3.Config{
 Endpoints: []string{"192.168.56.11:2379"},
 DialTimeout: 5 * time.Second,
 }
 //建立客户端
 if client, err = clientv3.New(config); err != nil {
 fmt.Println(err)
 return
 }
 //用于读写etcd键值对
 kv = clientv3.NewKV(client)
 if getResp,err = kv.Get(context.TODO(),"/cron/jobs/job1",/*clientv3.WithCountOnly())*/);err !=nil {
 fmt.Println(err)
 return
 }else {
 fmt.Println(getResp.Kvs,getResp.Count)
 }
}

• 按目录读取键值对

package main
import (
 "context"
 "fmt"
 "github.com/coreos/etcd/clientv3"
 "time"
)
//按目录获取
func main() {
 var (
 config clientv3.Config
 client *clientv3.Client
 err error
 kv clientv3.KV
 getResp *clientv3.GetResponse
 )
 //建立连接
 config = clientv3.Config{
 Endpoints: []string{"192.168.56.11:2379"},
 DialTimeout: 5 * time.Second,
 }
 //建立客户端
 if client, err = clientv3.New(config); err != nil {
 fmt.Println(err)
 return
 }
 //用于读写etcd键值对
 kv = clientv3.NewKV(client)
 //取/cron/jobs/为前缀的所有key
 if getResp,err = kv.Get(context.TODO(),"/cron/jobs",clientv3.WithPrefix());err != nil {
 fmt.Println(err)
 return
 }else {
 //获取所有的kvs
 fmt.Println(getResp.Kvs)
 }
}

本文来自:51CTO博客

感谢作者:wx5b285b48ed74e

查看原文:Go语言(二十一) 常见的模块使用

• 编辑
• 预览