Golang并发测试辅助工具stop-and-go使用指南

stop-and-go是一个轻量级的Go语言并发测试辅助工具库，主要用于控制goroutine的启动和停止，特别适合在并发测试场景中使用。

主要功能

1. 提供简单的同步机制来控制goroutine的启动
2. 可以等待所有goroutine完成
3. 简化并发测试的编写

安装

go get github.com/yourusername/stop-and-go

基本用法

1. 基本示例

package main

import (
	"fmt"
	"time"
	"github.com/yourusername/stop-and-go"
)

func worker(id int, sg *stopandgo.StopAndGo) {
	fmt.Printf("Worker %d waiting to start\n", id)
	sg.Start() // 等待开始信号
	defer sg.Done() // 标记完成

	fmt.Printf("Worker %d started\n", id)
	time.Sleep(time.Second)
	fmt.Printf("Worker %d finished\n", id)
}

func main() {
	sg := stopandgo.New()

	// 启动5个worker
	for i := 0; i < 5; i++ {
		go worker(i, sg)
	}

	fmt.Println("Main: Starting workers...")
	sg.Release() // 释放所有等待的goroutine

	fmt.Println("Main: Waiting for workers to finish...")
	sg.Wait() // 等待所有goroutine完成
	fmt.Println("Main: All workers finished")
}

2. 并发测试示例

package main_test

import (
	"testing"
	"time"
	"github.com/yourusername/stop-and-go"
)

func TestConcurrentOperations(t *testing.T) {
	sg := stopandgo.New()
	var counter int

	// 启动10个goroutine增加计数器
	for i := 0; i < 10; i++ {
		go func() {
			sg.Start()
			defer sg.Done()
			
			// 临界区操作
			counter++
		}()
	}

	// 确保所有goroutine都已准备好
	time.Sleep(100 * time.Millisecond)
	
	// 释放所有goroutine
	sg.Release()
	
	// 等待所有goroutine完成
	sg.Wait()

	if counter != 10 {
		t.Errorf("Expected counter to be 10, got %d", counter)
	}
}

高级用法

1. 带超时的等待

func TestWithTimeout(t *testing.T) {
	sg := stopandgo.New()
	
	go func() {
		sg.Start()
		defer sg.Done()
		time.Sleep(2 * time.Second) // 模拟长时间运行的任务
	}()

	sg.Release()

	// 等待最多1秒
	if !sg.WaitTimeout(1 * time.Second) {
		t.Error("Timeout waiting for goroutines to finish")
	}
}

2. 多次使用StopAndGo

func TestMultiplePhases(t *testing.T) {
	sg1 := stopandgo.New()
	sg2 := stopandgo.New()
	
	var phase1, phase2 int

	// 启动goroutine
	for i := 0; i < 5; i++ {
		go func(id int) {
			sg1.Start()
			phase1++
			sg1.Done()
			
			sg2.Start()
			phase2++
			sg2.Done()
		}(i)
	}

	// 释放第一阶段
	sg1.Release()
	sg1.Wait()

	if phase1 != 5 {
		t.Errorf("Phase1: expected 5, got %d", phase1)
	}

	// 释放第二阶段
	sg2.Release()
	sg2.Wait()

	if phase2 != 5 {
		t.Errorf("Phase2: expected 5, got %d", phase2)
	}
}

实现原理

stop-and-go的核心是基于sync.WaitGroup和通道实现的。主要组件包括：

1. Start()方法：goroutine调用此方法等待开始信号
2. Release()方法：主goroutine调用此方法释放所有等待的goroutine
3. Done()方法：goroutine完成任务后调用
4. Wait()方法：主goroutine等待所有goroutine完成

注意事项

1. 确保每个Start()都有对应的Done()调用，否则Wait()会永远阻塞
2. Release()只需调用一次，多次调用不会有额外效果
3. 适用于测试场景，生产环境请根据需求评估使用

替代方案

如果stop-and-go不能满足需求，也可以考虑：

1. sync.WaitGroup：Go标准库提供的基本同步原语
2. errgroup.Group：支持错误传播的goroutine组
3. golang.org/x/sync/semaphore：加权信号量

stop-and-go的优势在于它提供了更简单的接口来专门解决"等待所有goroutine准备好后同时开始"这一特定场景的需求。

希望这个指南能帮助你有效地使用stop-and-go进行并发测试！