type Signal interface {
    String() string
    Signal() // to distinguish from other Stringers
}

func Notify(c chan<- os.Signal, sig ...os.Signal)

func Example4(){
	fmt.Println("Start running")
	// 定义一个需要自定义处理的信号量列表
	signs_handled_by_myself := []os.Signal{syscall.SIGINT, syscall.SIGQUIT}

	// 定义一个channel接收来自操作系统的信号,容量为1
	channel := make(chan os.Signal, 1)

	// Notify监听操作系统是否有发送信号，如果有就会通过往channel发送信号量的方式异步通知当前进程（有信号量的时候才会通知）
	signal.Notify(channel, signs_handled_by_myself...)		// Notify是一个非阻塞的方法，所以即使操作系统还没有发送信号到Notify，Nofity也不会阻塞。阻塞的工作应该交给下面的for range channel循环

	// 在主进程中接收Notify的通知并处理需要自定义处理的信号
	for sign := range channel{
		fmt.Printf("Receive signal from operation system: %s\n", sign)
	}
}

func Example5(){
	sigChan1 := make(chan os.Signal, 1)
	sigChan2 := make(chan os.Signal, 1)
	sigList1 := []os.Signal{syscall.SIGINT, syscall.SIGQUIT}
	sigList2 := []os.Signal{syscall.SIGINT}
	finishChan := make(chan struct{})

	// 监听系统发送过来的信号
	signal.Notify(sigChan1, sigList1...)
	signal.Notify(sigChan2, sigList2...)

	go func(){
		var cmd string
		for {
			_, err := fmt.Fscanln(os.Stdin, &cmd) // 如果有标准输出则视作为停止sigChan1和sigChan2接收自定义信号量

			if err != nil{
				log.Fatal(err)
			}
			
			if cmd == "1"{
				fmt.Println("Stop sigChan1")
				signal.Stop(sigChan1)		// signal.Stop方法只会清除掉sigChan1对应的自定义信号集合sig2,但是不会关闭sigChan1这个通道
			}else if cmd == "2"{
				fmt.Println("Stop sigChan2")
				signal.Stop(sigChan2)
			}else if cmd == "end"{
				fmt.Println("finish main goroutine")
				finishChan <- struct{}{}
			}
		}
	}()

loop:
	for{
		select {
		case sig1 := <- sigChan1:
			fmt.Printf("Sig from  sigChan1: %s\n", sig1)
		case sig2 := <- sigChan2:
			fmt.Printf("Sig from  sigChan2: %s\n", sig2)
			case <-finishChan:
				break loop
		}
	}
}

[root@VM-0-13-centos ~]# go run multiprocess_main
^CSig from  sigChan1: interrupt
Sig from  sigChan2: interrupt
^\Sig from  sigChan1: quit
^CSig from  sigChan1: interrupt
Sig from  sigChan2: interrupt
^\Sig from  sigChan1: quit
asdfadsf
2
Stop sigChan2
^CSig from  sigChan1: interrupt
^\Sig from  sigChan1: quit
2
Stop sigChan2
^CSig from  sigChan1: interrupt
1
Stop sigChan1
^Csignal: interrupt

var pids []int
//var waiting chan struct{}
func Example6(){
	sigs := []os.Signal{syscall.SIGINT, syscall.SIGQUIT,  syscall.SIGINT, syscall.SIGINT, syscall.SIGINT, syscall.SIGQUIT}
	sigChannel := make(chan os.Signal, 1) 		// 接收系统信号量的通道
	//waiting = make(chan struct{})
	listenSignal(sigChannel)	 // 监听通知信号量

	go sendSignal(sigs, sigChannel)	// 向当前进程发送信号量

	catchSignal(sigChannel)		//捕获信号量, 里面的for sigChannel会阻塞
}

// 准备通知信号量
func listenSignal(sigChannel chan os.Signal){
	sigs := []os.Signal{syscall.SIGINT, syscall.SIGQUIT}	// 定义需要自行处理的信号量

	signal.Notify(sigChannel, sigs...)		// 监听 sigs 列表中的信号量，非阻塞
}

// 捕获信号量
func catchSignal(sigChannel chan os.Signal){
	for sig := range sigChannel{
		//<- waiting
		fmt.Printf("Signal from os: %s\n", sig)
	}
}

// 向当前进程发送信号量,第一参是要发送的信号量
func sendSignal(sigs []os.Signal, sigChannel chan os.Signal){
	current_pids := getPids()	    // 获取当前进程相关的pid

	// 根据pid获取进程的对象 *Process, 并向这些与当前进程相关的pid发送信号
	for _, pid := range current_pids{
		process, err := os.FindProcess(pid)
		if err != nil{
			log.Fatalf("Fail to get process by pid: %d", pid)
		}
		for _, sig := range sigs{
			process.Signal(sig)		// 向这个进程发送信号量
time.Sleep(1 * time.Second)

			//waiting <- struct{}{}		// 等待catchSignal方法把信号接收到才发下一个信号(但是这么干的话最后会永久阻塞，原因是除了第一个pid是顺利被catchSignal捕获到之外，向其他的pid发送的信号都不会被catchSignal捕获到，因为那些pid不是本进程的pid。)
		}
	}

	// 发完之后通知main goroutine唤醒阻塞，结束主协程
	close(sigChannel)
}

func getPids() []int{
	if pids != nil {	// 如果pid已经获取过了，就直接返回
		return pids
	}

	// 执行命令 ps -aux | grep multiprocess_main |grep -v "go run" | grep -v "grep" | awk '{print $2}'
	// awk 后的命令必须用单引号不能用双引号
	cmds := []*exec.Cmd{
		exec.Command("ps", "-aux"),
		exec.Command("grep", "multiprocess_main"),
		exec.Command("grep", "-v", "go run"),
		exec.Command("grep", "-v", "grep"),
		exec.Command("awk", "{print $2}"),
	}

	// 运行命令得到结果res
	res, err := runCmds(cmds)
	if err != nil{
		log.Fatalf("Fail to get pids: %s", err)
	}

	// 将获取到的res结果（里面放着字符串的pid）转为[]int类型
	for _, r := range res{
		pid, err := strconv.Atoi(strings.TrimSpace(r))	// TrimSpace 可以去掉字符串的空白符如空格 \t \n
		if err != nil{
			log.Fatalf("Fail to change type from string to int: %s | err: %s", r, err)
		}
		pids = append(pids, pid)
	}

	return pids
}

func runCmds(cmds []*exec.Cmd) (lines []string, err error){
	var output []byte
	firstCmd := true
	for _, cmd := range cmds {
		if !firstCmd{
			// 将上一个cmd的输出作为本次cmd的输入
			var cmdInput bytes.Buffer
			cmd.Stdin = &cmdInput
			cmdInput.Write(output)
		}

		var cmdOutput bytes.Buffer
		cmd.Stdout = &cmdOutput
		if err := cmd.Start(); err != nil{
			log.Fatalf("running cmd '%s' failed, reason: %s", cmd.Path, err)
		}
		cmd.Wait()

		// 将命令的输出从动态缓冲cmdOutput保存到output中
		output = cmdOutput.Bytes()
		firstCmd = false
	}

	// 此时output保存着命令的运行结果，但是output此时是一堆字节流，每一个元素都是单字节，而我们想要的是一个int类型的切片，因此这里需要做一下转换
	// 转换的思路就是以\n作为分隔符，将output中每2个\n之间的字节流单独提出来转为string再转为int即可
	var outputBuffer bytes.Buffer
	outputBuffer.Write(output)		// 这两句可以将一个[]byte类型的数据包装为bytes.Buffer的动态缓冲区数据

	for{
		eachLine, err := outputBuffer.ReadBytes('\n')	    // 循环获取以\n为分隔符的内容
		res := strings.TrimSpace(string(eachLine))
		if res != "" {
			lines = append(lines, res)
		}
		if err != nil {
			if err == io.EOF{
				break
			}else{
				return nil, err
			}
		}
	}

	return lines, nil
}

func StartProcess(name string, argv []string, attr *ProcAttr) (*Process, error) {
	testlog.Open(name)
	return startProcess(name, argv, attr)
}