Golang中布尔变量在作用域外被修改的问题

该函数仅被调用一次。它包含一个循环，持续获取股票价格并将其放入缓冲通道，最多约20个。然后等待通道清空，再获取下一批数据，依此类推。浏览器页面有一个取消按钮，通过将 doRealTime 设置为 false 来通知循环退出。这按预期工作；但是，如果我再次运行它，当它执行到 wg.wait() 时，doRealTime 不知何故被设置为 false，尽管没有执行任何代码来这样做。将 doRealTime 设为模块级变量可以解决问题，但我不明白原因。

在Golang中，这个问题涉及到闭包捕获变量和goroutine执行时机的问题。当你将doRealTime声明为函数级变量时，在goroutine中捕获的是这个局部变量的引用。当RealTimeQuotes()函数返回后，这个局部变量可能被垃圾回收或处于未定义状态，导致goroutine中访问到意外的值。

以下是问题重现和解决方案的示例：

package main

import (
	"fmt"
	"sync"
	"time"
)

var wg sync.WaitGroup
var channelStocks chan string
var channelBufferSize = 30

// 问题版本：doRealTime作为局部变量
func RealTimeQuotesProblem() {
	var doRealTime bool // 局部变量
	
	wg = sync.WaitGroup{}
	doRealTime = true
	channelStocks = make(chan string, channelBufferSize)
	
	// goroutine捕获局部变量doRealTime的引用
	go func() {
		time.Sleep(100 * time.Millisecond) // 模拟延迟
		doRealTime = false // 这里修改的是局部变量的副本
		fmt.Println("Goroutine set doRealTime to false")
	}()

	counter := 0
	for doRealTime {
		counter++
		if counter > 3 {
			break // 防止无限循环
		}
		fmt.Printf("Loop iteration %d, doRealTime=%v\n", counter, doRealTime)
		time.Sleep(50 * time.Millisecond)
	}
	fmt.Println("Function exited, doRealTime=", doRealTime)
}

// 解决方案：使用模块级变量
var doRealTimeGlobal bool

func RealTimeQuotesSolution() {
	wg = sync.WaitGroup{}
	doRealTimeGlobal = true // 修改模块级变量
	channelStocks = make(chan string, channelBufferSize)
	
	go func() {
		time.Sleep(100 * time.Millisecond)
		doRealTimeGlobal = false // 修改的是同一个模块级变量
		fmt.Println("Goroutine set doRealTimeGlobal to false")
	}()

	counter := 0
	for doRealTimeGlobal {
		counter++
		if counter > 3 {
			break
		}
		fmt.Printf("Loop iteration %d, doRealTimeGlobal=%v\n", counter, doRealTimeGlobal)
		time.Sleep(50 * time.Millisecond)
	}
	fmt.Println("Function exited, doRealTimeGlobal=", doRealTimeGlobal)
}

// 更好的解决方案：使用通道进行同步控制
func RealTimeQuotesBetter() {
	stopChan := make(chan struct{}) // 控制通道
	wg = sync.WaitGroup{}
	channelStocks = make(chan string, channelBufferSize)
	
	// 启动控制goroutine
	go func() {
		time.Sleep(100 * time.Millisecond)
		close(stopChan) // 发送停止信号
		fmt.Println("Goroutine sent stop signal")
	}()

	counter := 0
	for {
		select {
		case <-stopChan:
			fmt.Println("Received stop signal, exiting")
			return
		default:
			counter++
			if counter > 3 {
				return
			}
			fmt.Printf("Loop iteration %d\n", counter)
			time.Sleep(50 * time.Millisecond)
		}
	}
}

func main() {
	fmt.Println("=== Problem Version ===")
	RealTimeQuotesProblem()
	
	time.Sleep(200 * time.Millisecond)
	
	fmt.Println("\n=== Solution Version ===")
	RealTimeQuotesSolution()
	
	time.Sleep(200 * time.Millisecond)
	
	fmt.Println("\n=== Better Solution ===")
	RealTimeQuotesBetter()
}

在你的代码中，当RealTimeQuotes()函数第一次执行完成后，局部变量doRealTime的作用域结束。当函数第二次执行时，创建了一个新的doRealTime变量，但之前启动的goroutine可能还在运行（或者其修改影响了内存状态），导致新变量被意外修改。

模块级变量之所以能解决问题，是因为：

1. 所有访问都指向同一个内存位置
2. 变量的生命周期与程序运行周期一致
3. goroutine修改的是同一个变量

更健壮的解决方案是使用通道来控制goroutine的停止：

func (realTime RealTime) RealTimeQuotesBetter() {
	stopChan := make(chan struct{})
	wg = sync.WaitGroup{}
	channelStocks = make(chan *data.StockRealTime, channelBufferSize)
	
	// 启动停止监听goroutine
	go func() {
		<-realTimeExecutionChannel
		close(stopChan) // 发送停止信号
		channelStocks = make(chan *data.StockRealTime, channelBufferSize)
		realTimeExecutionChannel <- struct{}{}
	}()

	for {
		select {
		case <-stopChan:
			return // 收到停止信号，退出函数
		default:
			// 原有的业务逻辑
			for tickKey, tick := range newTicksMap {
				var stockRealTime data.StockRealTime
				wg.Add(1)
				channelStocks <- &stockRealTime
			}
			close(channelStocks)
			wg.Wait()
		}
	}
}

这种使用通道的模式是Go语言中推荐的goroutine通信方式，避免了共享变量的竞态条件问题。