Go编程 技巧 for range 和channl（除了select的另外一种）

案例:

notify_ch, err := tx.EnableNotifications(func(value []byte) {

在一个通道轮询 赌赛的 一旦通道有数据 拿马上拿出来 直到通道关闭 它也就死循环结束从而消亡了

【相比较 select需要一个关闭条件的 这个不需要条件 通道关闭 它自动就关闭了go程自动结束】

for range会一直读取数据直到，chan关闭。

无缓冲chan相当于一个开关，不存储数据，同步阻塞类型，

如果没有for rang不断读取数据，chan不会有数据不断流入流出

测试代码:

package main

import "fmt"

// channel 无缓存类型不能读写值，会同步阻塞，相当于一个开关
func producter(numbs ...int) <-chan int {
	out := make(chan int)
	go func() {
		defer close(out)
		for _, n := range numbs {
			fmt.Printf("生产%d\r\n", n)
			out <- n
		}
	}()
	return out
}
func square(out <-chan int) <-chan int {
	in := make(chan int)
	go func() {
		defer close(in)
		for n := range out {
			fmt.Printf("消费%d\r\n", n) // 验证如果没有rang读取的情况是否阻塞
			in <- n * n
		}
	}()
	return in
}
func main() {
	out := producter(1, 2, 3, 4)
	in := square(out)
	i := 0
	// range会一直获取数据直到chan关闭
	for ret := range in {
		i++
		fmt.Printf("main i=%d ret=%d\r\n", i, ret)

	}
	fmt.Println(i, in)
	fmt.Println(i, <-in)
}

应用 蓝牙我是主机 现在和从机连接以后

从机疯狂发消息过来 我可能接受处理应接不暇

以前做法是

func BLE_HEX_DATA_CODE_RX(param interface{}, ch chan int) bool {
	pack, ok := (param).(PACK_DATA)
	if !ok {
		fmt.Printf("BLE_HEX_DATA_CODE_RX Assert\r\n")
		return false
	}
	var hex_data m_hex_data
	if uint16(len(pack.Data)) != uint16(unsafe.Sizeof(hex_data)) {
		log.Printf("[BG] Data length not correct:%d\r\n", len(pack.Data))
		return false
	}
	/*
		Todo 开始个性话处理
	*/
	Savefile("./hexdata.bin", pack.GetByteArray())
	return true
}

 也就是收到通道消息以后 就savefile 这样调用函数

它的潜在问题是:消息疯狂过来的时候 这个函数可能处理不过来！

修改就是这里不处理 这里只是在做一个通道TX出去 在另外一个协程里面慢慢处理

另外一个协程就是在for rang

修改后 对比2个文件 是一样的！

func Savefile(path string, content []byte) {
	os.Remove(path)
	f, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0777)
	if err != nil {
		log.Printf("Open PATH failed %+v\r\n", err)
	} else {
		_, err = f.Write(content)
	}

	defer f.Close()

	myfile, err := os.ReadFile(path)
	if err != nil {
		log.Printf("Read FILEPATH failed\r\n")
		return
	}
	log.Printf("myfile:%+v\r\n", myfile)
	//log.Printf("myfile:%s\r\n", string(myfile))

}

func hex_data_handler(ble_hex_in chan PACK_DATA) {
	var hex_data m_hex_data

	for p := range ble_hex_in {
		var data [unsafe.Sizeof(hex_data)]uint8
		copy(data[:], p.Data)
		hex_data = *(*m_hex_data)(unsafe.Pointer(&data))
		fmt.Printf("hex_data:%+v", hex_data)

		if !hex_data.VerifyCRC() {
			log.Printf("[BLE]HEX_DATA CRC wrong\r\n")
		} else {
			Savefile("./hexdata2.bin", p.GetByteArray())
		}
	}
}

func BLE_HEX_DATA_CODE_RX(param interface{}, ch chan int) bool {
	pack, ok := (param).(PACK_DATA)
	if !ok {
		fmt.Printf("BLE_HEX_DATA_CODE_RX Assert\r\n")
		return false
	}
	var hex_data m_hex_data
	if uint16(len(pack.Data)) != uint16(unsafe.Sizeof(hex_data)) {
		log.Printf("[BG] Data length not correct:%d\r\n", len(pack.Data))
		return false
	}
	/*
		Todo 开始个性话处理
	*/
	Savefile("./hexdata.bin", pack.GetByteArray())
	/*
		?有可能消费没有完成 这个函数就消亡了 要注意测试
	*/

	hex_data_chan := make(chan PACK_DATA, 20)
	go hex_data_handler(hex_data_chan)
	defer close(hex_data_chan)
	hex_data_chan <- pack

	return true
}