一个备份任务分发的Golang实现原型

xcltapestry · · 3932 次点击 · · 开始浏览    
这是一个创建于 的文章,其中的信息可能已经有所发展或是发生改变。

       前段在玩协程时跟着libtask的作者Russ Cox转到Golang了,一堆重量级大牛们想出来的东西就是不同,思路非常特别,和常用的差别有点大,

但非常注重实用,减少了一堆的语法糖后,让人重新思考,开发语言本来应当是怎么样?如果用来做服务端开发的话,真的是很不错的东西。

       在一个练习中,我设计了个发送Oracle数据库备份任务的简单场景。通过 发送备份任务到各个客户端,来练习Golang中的sync.WaitGroup.

       sync.WaitGroup是Golang提供的一种简单的同步方法集合。它有三个方法.
             Add() 添加计数,数目可以为一个,也可以为多个。
             Done() 减掉一个计数,如果计数不为0,则Wait()会阻塞在那,直到全部为0
             Wait() 等待计数为0.

 

         弄个例子直观的见识下:

package main

import (
	"fmt"
	"sync"
)

var waitGrp sync.WaitGroup

func main() {

	bakJobs := []string{"Full Database", "Archive Log", "Control File"}

	for i := 0; i < len(bakJobs); i++ {
		waitGrp.Add(1) //add job

		go func(jobName string) {
			fmt.Println(jobName)
			waitGrp.Done() //sub job
		}(bakJobs[i])
	}

	waitGrp.Wait()
}

/*
E:\GitHub\Golang\XCLTools\src\test>wg
Full Database
Archive Log
Control File
*/
可以看到会依次打印bakJobs中的数据。但如果把waitGrp.Wait()注释掉。啥都不会输出。即,在for后,wait会等待所有的job执行完后,

才会执行后面的。  这个例子说明,除了熟悉了下waitGroup的使用外,还说明waitGroup能保证作业的执行顺序,及会等待所有子作业全部完成再继续的特性。

       就Oracle数据库备份本身而言,在这使用go func()...其实意义不大,所以我想了个更复杂点的场景,给多个服务器上的数据库批量发送备份指令,并依数据库

的重要性顺序来执行。

      下面是实现的代码(纯演示,忽略掉其它通信和逻辑处理方面的东西):       

package main

import (
	"fmt"
	"sync"
)

var waitGrp sync.WaitGroup

func main() {
	waitGrp.Add(2)
	for _, ip := range []string{"ip1", "ip2"} {
		go doJobs(ip)
		fmt.Println("IP = ", ip)
	}
	waitGrp.Wait()
	fmt.Println("main() end.")
}

func doJobs(ip string) {

	bakJobs := []string{"Full Database", "Archive Log", "Control File"}
	for i := 0; i < len(bakJobs); i++ {
		doBak(ip, i, bakJobs[i])
	}
	fmt.Println("The backup is complete!")
	fmt.Println("......")
	defer waitGrp.Done()
}

func doBak(ip string, id int, jobName string) (bool, error) {
	fmt.Println("doBak() :", ip, " - ", id, " - ", jobName)
	return true, nil
}

/*
IP =  ip1
IP =  ip2
doBak() : ip1  -  0  -  Full Database
doBak() : ip1  -  1  -  Archive Log
doBak() : ip1  -  2  -  Control File
The backup is complete!
......
doBak() : ip2  -  0  -  Full Database
doBak() : ip2  -  1  -  Archive Log
doBak() : ip2  -  2  -  Control File
The backup is complete!
......
main() end.

*/

    代码中,会首先向各个IP发送执行jobs的指令。各个指令执行的时间有长有短,用go func()...能保证是在同一时间向所有相关IP发出命令让各IP依次执行相关备份。

主goroutine则等待这个总作业全部结束后再执行其它。同时由于waitGroup的顺序性,能保证重要点的ip,可以优先执行。

    我设计场景的目的是想在例子中加入更多的Golang新鲜元素来增强感觉,所以针对上一个例子,我又设想了一个情况,因为数据库备份是很耗时的,且要等待

所有IP上的作业都执行完毕要花费很长时间,如果这时,用户要求取消这次作业怎么办?

    于是这就有了下面的例子:

package main

import (
	"bufio"
	"fmt"
	"os"
	"sync"
	"time"
)

var waitGrp sync.WaitGroup

func main() {

	ch := make(chan bool)

	go schedule(ch)

	r := bufio.NewReader(os.Stdin)
	for {
		time.Sleep(time.Second)

		fmt.Print("Command:> ")
		ln, _, _ := r.ReadLine()
		cmd := string(ln)

		if "q" == cmd || "quit" == cmd {
			close(ch)
			break
		} else {
			fmt.Println(" = cmd = ", cmd, "\n")
		}
	}

	waitGrp.Wait()
	fmt.Println("main() end.")
}

func schedule(ch chan bool) {

	for _, ip := range []string{"ip1", "ip2"} {
		waitGrp.Add(1)

		go doJobs(ip, ch)
		fmt.Println("schedule() IP = ", ip)
	}
	fmt.Println("schedule() end.")
	return
}

func doJobs(ip string, ch chan bool) {

	defer waitGrp.Done()

	for i := 0; i < 10; i++ {

		select {
		case <-ch:
			fmt.Println("doJobs() ", ip, "=>Job Cancel......")
			return
		default:
		}

		fmt.Println("doJobs()...... ", ip, " for:", i)
		time.Sleep(time.Second)
	}
}

/*

E:\GitHub\Golang\XCLTools\src\test>wg5
schedule() IP =  ip1
schedule() IP =  ip2
schedule() end.
doJobs()......  ip1  for: 0
doJobs()......  ip2  for: 0
Command:> doJobs()......  ip1  for: 1
doJobs()......  ip2  for: 1
doJobs()......  ip1  for: 2
doJobs()......  ip2  for: 2
doJobs()......  ip1  for: 3
doJobs()......  ip2  for: 3
doJobs()......  ip1  for: 4
doJobs()......  ip2  for: 4
doJobs()......  ip1  for: 5
doJobs()......  ip2  for: 5
doJobs()......  ip1  for: 6
doJobs()......  ip2  for: 6
doJobs()......  ip1  for: 7
doJobs()......  ip2  for: 7
doJobs()......  ip1  for: 8
doJobs()......  ip2  for: 8
doJobs()......  ip1  for: 9
doJobs()......  ip2  for: 9
q
main() end.

E:\GitHub\Golang\XCLTools\src\test>wg5
schedule() IP =  ip1
schedule() IP =  ip2
schedule() end.
doJobs()......  ip1  for: 0
doJobs()......  ip2  for: 0
Command:> doJobs()......  ip2  for: 1
doJobs()......  ip1  for: 1
doJobs()......  ip2  for: 2
doJobs()......  ip1  for: 2
doJobs()......  ip2  for: 3
doJobs()......  ip1  for: 3
q
doJobs()  ip2 =>Job Cancel......
doJobs()  ip1 =>Job Cancel......
main() end.
*/
        我用了个for{},让用户在作业执行过程中,可以输入指令退出执行。并且,在退出过程中,各个IP也会作相关的取消处理。以保证不会因

强制中断而出现一些不必要的麻烦。

   这个例子到这,已经引入了足够多的东西,我觉得已达到练习的目的,场景就先到此了。

   在此整理下,以备后查。


   MAIL:  xcl_168@aliyun.com

  BLOG: http://blog.csdn.net/xcl168



有疑问加站长微信联系(非本文作者)

本文来自:CSDN博客

感谢作者:xcltapestry

查看原文:一个备份任务分发的Golang实现原型

入群交流(和以上内容无关):加入Go大咖交流群,或添加微信:liuxiaoyan-s 备注:入群;或加QQ群:692541889

3932 次点击  
加入收藏 微博
1 回复  |  直到 2018-03-07 15:55:41
暂无回复
添加一条新回复 (您需要 登录 后才能回复 没有账号 ?)
  • 请尽量让自己的回复能够对别人有帮助
  • 支持 Markdown 格式, **粗体**、~~删除线~~、`单行代码`
  • 支持 @ 本站用户;支持表情(输入 : 提示),见 Emoji cheat sheet
  • 图片支持拖拽、截图粘贴等方式上传