Go套路 Scan 轮询变中断

已于 2022-04-18 13:01:15 修改
阅读量344 收藏
点赞数 1
分类专栏： GO 文章标签： golang
于 2022-04-18 11:47:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42381351/article/details/124241783
版权

V1.0

package main

import (
	"fmt"
	"time"
)

func loopcheck(ch chan bool) {
	var i int = 0
	for {
		time.Sleep(time.Second)
		i++
		if i == int(2) {
			ch <- true
		}
	}
}
func main() {
	ch := make(chan bool)
	go loopcheck(ch)
	ticker_period := 1000 * time.Millisecond
	t := time.NewTicker(ticker_period)
	for {
		select {
		case b := <-ch:
			fmt.Println("中断收到啦!", b)
		case <-t.C:
			fmt.Println("main")
		}
	}
}

可以但是有个任务没有停止！

V2

package main

import (
	"fmt"
	"time"
)

func loopcheck(ch chan bool) {
	var i int = 0
	if ch == nil {
		fmt.Println("loopcheck die")
		time.Sleep(time.Second)
		return
	}
	for {
		time.Sleep(time.Second)
		i++
		if i == int(2) {
			ch <- true
		}
	}
}
func main() {
	ch := make(chan bool)
	go loopcheck(ch)
	ticker_period := 1000 * time.Millisecond
	t := time.NewTicker(ticker_period)
	for {
		select {
		case b := <-ch:
			fmt.Println("中断收到啦!", b)
			close(ch)
		case <-t.C:
			fmt.Println("main")
		}
	}
}

他的测试是

[Running] go run "c:\Users\Koson.Gong\Desktop\sgo\my\myselfkill.go"

main

main

中断收到啦! true

中断收到啦! false

panic: close of closed channel

goroutine 1 [running]:

main.main()

    c:/Users/Koson.Gong/Desktop/sgo/my/myselfkill.go:32 +0x17a

exit status 2

所以我没有必要去关闭了 因为他已经关闭了 ！

怎么会关闭的呢？ 奇怪啊

V3用这个把

package main

import (
	"fmt"
	"time"
)

func loopcheck(ch chan bool) {
	var i int = 0
	/*
		这个办法C风格太强 不好 使用Go风格的
	*/
	/*
		for {
			time.Sleep(800 * time.Millisecond)
			i++
			if i == int(2) {
				//close(ch)
				ch <- true
				return
			}
		}
	*/

	ticker_period := 800 * time.Millisecond
	t := time.NewTicker(ticker_period)
	for {
		select {
		case <-t.C:
			i++
			fmt.Println(i)
			if i == int(2) {
				//close(ch)
				ch <- true
				return //自动消亡这个协程
			}
		}
	}

}
func main() {
	ch := make(chan bool)
	go loopcheck(ch)
	ticker_period := 1000 * time.Millisecond
	t := time.NewTicker(ticker_period)
	for {
		select {
		case b := <-ch:
			fmt.Println("中断收到啦!", b)
		case <-t.C:
			fmt.Println("main")
		}
	}
}

遗留问题 即时 谁关闭的？

package main

import (
	"fmt"
	"time"
)

func loopcheck(ch chan bool) {
	var cnt int = 0
	ticker_period := 800 * time.Millisecond
	t := time.NewTicker(ticker_period)
	for {
		select {

		case <-t.C:
			fmt.Println(cnt)
			cnt++
			if cnt == 3 {
				//close(ch)
				ch <- true
			}
		}
	}
}
func main() {
	ch := make(chan bool, 2)
	go loopcheck(ch)
	ticker_period := 1000 * time.Millisecond
	t := time.NewTicker(ticker_period)
	for {
		select {
		//case b := <-ch:
		//	fmt.Println("中断收到啦!", b)
		case <-ch:
			if x, ok := <-ch; ok {
				fmt.Println("中断收到啦!", x)
			}
		case <-t.C:
			fmt.Println("main")//这个代码测试有问题 前面的case会把后面的case抢占
		}
	}
}

带着这个问题 学习TingGo的SCAN

先看MUKA的

package api
import 	"github.com/muka/go-bluetooth/bluez/profile/adapter"

func Discover(a *adapter.Adapter1, filter *adapter.DiscoveryFilter,)//参数
             (chan *adapter.DeviceDiscovered, func(), error) {//返回值 看后图

	a.SetPairable(false)//操作参数1 adapter
	a.SetDiscoverable(false)//操作参数1 adapter 所以不能主从一体了吗？
    a.SetPowered(true)//操作参数1 adapter

	filterMap := make(map[string]interface{})
	if filter != nil {//操作参数2 万能过滤器 自己去转化ToMap
		filterMap = filter.ToMap()
	}
	a.SetDiscoveryFilter(filterMap)//操作参数1
	a.StartDiscovery()//操作参数1

	ch, discoveryCancel, err := a.OnDeviceDiscovered()
	cancel := func() {
		a.StopDiscovery()
		discoveryCancel()
	}
	return ch, cancel, nil
	/*
	返回结果1--是ch--------它来自a.OnDeviceDiscovered 所以OnDeviceDiscovered是关键
	返回结果2--是一个函数---你调用它就是调用了i-a.StopDiscovery II-discoveryCancel
	
	*/
}

自己写小程序 效果一样 重复关闭

package main

import (
	"fmt"
	"time"
)

func loopcheck() (chan bool, func()) {

	ch := make(chan bool)
	go func() {
		var i int = 0
		for {
			time.Sleep(time.Second)
			i++
			if i == int(3) {
				ch <- true
			}
		}
	}()
	cancel := func() {
		close(ch)
	}
	return ch, cancel
}
func main() {
	c, fun := loopcheck()
	ticker_period := 1000 * time.Millisecond
	t := time.NewTicker(ticker_period)
	for {
		select {
		case b := <-c:
			fmt.Println("中断收到啦!", b)
			fun()
		case <-t.C:
			fmt.Println("main")
		}
	}
}

scan是怎么做的

这个 怎么写一个毒杀函数

package main

import (
	"fmt"
	"time"
)

type Adapter struct {
	cancelChan chan struct{}
	num        int
}

func (a *Adapter) Scan(callback func(*Adapter)) bool {
	if a.cancelChan != nil {
		fmt.Println("ERR Scan")
		return false
	}
	/*
		程序进来的时候 通道 a.cancelChan 必须是关闭的
		因为我马上回给他重写分配内存的

		通道是谁关闭的？是用户自己再外面回调关闭的
	*/
	cancelChan := make(chan struct{})
	a.cancelChan = cancelChan
	for {
		a.num++
		time.Sleep(time.Second)
		fmt.Println(a.num)
		if a.num%int(3) == 0 {
			fmt.Println("条件何时 扫到东西 执行一次")
			callback(a)
		}
	}
}

func (a *Adapter) StopScan() bool {
	if a.cancelChan == nil {
		fmt.Println("ERR StopScan")
		return false
	}
	close(a.cancelChan)
	a.cancelChan = nil
	fmt.Println("StopScan")
	return true
}

func main() {
	var A Adapter = Adapter{num: 0}
	A.Scan(
		func(B *Adapter) {
			fmt.Println("B.num", B.num)
			if B.num == int(6) {
				B.StopScan()
			}
		})

	for {
	}
}

/*

Koson.Gong@MC2077 MINGW64 ~/Desktop/sgo/my (master)
$ go build myscan.go

Koson.Gong@MC2077 MINGW64 ~/Desktop/sgo/my (master)
$ ./myscan.exe
1
2
3
条件何时 扫到东西 执行一次
B.num 3
4
5
6
条件何时 扫到东西 执行一次
B.num 6
StopScan
7
8
9
条件何时 扫到东西 执行一次
B.num 9
10

*/

修改 也不行

package main

import (
	"fmt"
	"time"
)

type Adapter struct {
	cancelChan chan struct{}
	num        int
}

func (a *Adapter) Scan(callback func(*Adapter)) bool {
	if a.cancelChan != nil {
		fmt.Println("ERR Scan")
		return false
	}
	/*
		程序进来的时候 通道 a.cancelChan 必须是关闭的
		因为我马上回给他重写分配内存的

		通道是谁关闭的？是用户自己再外面回调关闭的
	*/
	cancelChan := make(chan struct{})
	a.cancelChan = cancelChan
	go func() {
		for {
			a.num++
			time.Sleep(time.Second)
			fmt.Println(a.num)
			if a.num%int(3) == 0 {
				fmt.Println("条件何时 扫到东西 执行一次")
				callback(a)
			}
		}
	}()
	for {
		select {
		case <-cancelChan:
			fmt.Println("--- OUT ---")
			return true
		}
	}
}

func (a *Adapter) StopScan() bool {
	if a.cancelChan == nil {
		fmt.Println("ERR StopScan")
		return false
	}
	close(a.cancelChan)
	a.cancelChan = nil
	fmt.Println("StopScan")
	return true
}

func main() {
	var A Adapter = Adapter{num: 0}
	A.Scan(
		func(B *Adapter) {
			fmt.Println("B.num", B.num)
			if B.num == int(6) {
				B.StopScan()
			}
		})

	for {
	}
}

/*

Koson.Gong@MC2077 MINGW64 ~/Desktop/sgo/my (master)
$ go build myscan.go

Koson.Gong@MC2077 MINGW64 ~/Desktop/sgo/my (master)
$ ./myscan.exe
1
2
3
条件何时 扫到东西 执行一次
B.num 3
4
5
6
条件何时 扫到东西 执行一次
B.num 6
StopScan
7
8
9
条件何时 扫到东西 执行一次
B.num 9
10

*/

不能再里面继续go了！

下面终于成功了！！！

package main

import (
	"fmt"
	"time"
)

type Adapter struct {
	cancelChan chan struct{}
	num        int
}

func (a *Adapter) Scan(callback func(*Adapter)) bool {
	if a.cancelChan != nil {
		fmt.Println("ERR Scan")
		return false
	}
	/*
		程序进来的时候 通道 a.cancelChan 必须是关闭的
		因为我马上回给他重写分配内存的

		通道是谁关闭的？是用户自己再外面回调关闭的
	*/
	cancelChan := make(chan struct{})
	a.cancelChan = cancelChan

	ticker_period := 1000 * time.Millisecond
	t := time.NewTicker(ticker_period)
	for {
		select {
		case <-t.C:
			a.num++
			fmt.Println(a.num)
			callback(a)
		case <-cancelChan:
			fmt.Println("--OUT---")
			return true
		}

	}
}

func (a *Adapter) StopScan() bool {
	if a.cancelChan == nil {
		fmt.Println("ERR StopScan")
		return false
	}
	close(a.cancelChan)
	a.cancelChan = nil
	fmt.Println("StopScan")
	return true
}

func main() {
	var A Adapter = Adapter{num: 0}
	A.Scan(
		func(B *Adapter) {//这里的B其实也是A 因为调用再Scan里面赋值了A
			fmt.Println("B.num", B.num)
			if B.num == int(6) {
				B.StopScan()
			}
		})

	for {
	}
}

可以利用它完成轮询变中断！

比如过一段时间 断开连接

package main

import (
	"fmt"
	"time"
)

type BleStatus struct {
	cancelChan  chan struct{}
	isconnected bool
}

func (a *BleStatus) Check(callback func(*BleStatus)) {
	if a.cancelChan != nil {
		fmt.Println("ERR Scan")
		return
	}

	cancelChan := make(chan struct{})
	a.cancelChan = cancelChan

	ticker_period := 1000 * time.Millisecond
	t := time.NewTicker(ticker_period)
	var num int = 0
	for {
		select {
		case <-t.C:
			num++
			fmt.Println(num)
			if num == 3 {
				a.isconnected = false
			}
			callback(a)
		case <-cancelChan:
			fmt.Println("--OUT---")
			return
		}

	}
}

func (a *BleStatus) StopCheck() bool {
	if a.cancelChan == nil {
		fmt.Println("ERR StopCheck")
		return false
	}
	close(a.cancelChan)
	a.cancelChan = nil
	fmt.Println("StopCheck")
	return true
}

func main() {
	var A BleStatus = BleStatus{isconnected: true}
	A.Check(
		func(B *BleStatus) { //这里的B其实也是A 因为调用再Scan里面赋值了A
			fmt.Println("B.num", B.isconnected)
			if B.isconnected == false {
				B.StopCheck()
			}
		})
	fmt.Println("HELLO WORLD")
	for {
	}
}

GKoSon
关注
专栏目录
中断和轮询
glory的博客
09-07 5258
外部设备与中央处理器交互一般有两种手段：轮询和中断。 轮询（Polling） 很多I/O设备都有一个状态寄存器，用于描述设备当前的工作状态，每当设备状态发生改变时，设备将修改相应状态寄存器位。通过不断查询设备的状态寄存器，CPU就可以了解设备的状态，从而进行必要的I/O操作。为了节约CPU资源，查询工作往往不是连续的，而是定时进行。 轮询方式具有简单、易实现、易控制等优势，在很多小型系统中有大量应用。对那些实时敏感性不高、具有大量CPU资源的系统来说，轮询方式有很广泛的应用。最典型的用途就是...
中断与轮询
Lrrent的博客
04-09 1万+
轮询与中断 外部设备与中央处理器交互一般有两种手段：轮询和中断。 （1）轮询（Polling） 很多I/O设备都有一个状态寄存器，用于描述设备当前的工作状态，每当设备状态发生改变时，设备将修改相应状态寄存器位。通过不断查询设备的状态寄存器，CPU就可以了解设备的状态，从而进行必要的I/O操作。为了节约CPU资源，查询工作往往不是连续的，而是定时进行。 轮询方式具有简单、易实现、易控制等优势，
探索Goscan：一款高效、易用的Go语言代码扫描工具
gitblog_00056的博客
04-10 807
探索Goscan：一款高效、易用的Go语言代码扫描工具 goscanInteractive Network Scanner项目地址:https://gitcode.com/gh_mirrors/go/goscan 在编程世界中，代码质量是至关重要的。它不仅影响着软件的稳定性和可维护性，还直接影响用户体验。为了确保代码的质量，开发团队通常会借助静态代码分析工具。今天，我们要介绍的是一个名为Gosc...
go语言中的Scan函数简介
ThinkStu的博客
07-16 4806
String scan，从字符串中读取数据。Sscanf 的用法与 Scanf 类似，只是会从字符串中读取数据而不是标准输入。：按照指定格式对输入进行解析。在 Go 语言中，从标准输入（默认是键盘）读取数据可以使用 fmt 包中的 Scan 和 Scanln 函数。：类似于 Scan，但是只能读取一行数据（将换行符视为终止），如果输入的数据格式不正确，将返回错误。：请勿混淆各种输入方式的用法。获取输入，但是却采用了。：注意这里是 &num。
go中fmt.Scan系列函数的具体使用（易用+举例）
qq_39665216的博客
05-15 565
golang中的Scan, Scanf, Scanln的使用例子即常用特性
golongpoll:golang长轮询库。 通过HTTP长轮询服务器和客户端使Web发布订阅变得容易
05-13
Golang长轮询库。 通过HTTP长轮询服务器和客户端使Web发布订阅变得容易。 支持golang v1.9及更高版本。 资源 -显示如何使用longpoll服务器和go / js客户端。 如果您想创建自己的客户端。 快速开始 要创建longpoll...
key_scan.rar_key_scan_定时中断按键_按键中断检测
09-23
本文将深入探讨“key_scan.rar_key_scan_定时中断按键_按键中断检测”这个主题，重点解析其中的按键扫描程序设计，特别是利用定时中断来提高按键检测的准确性和效率。 1. **按键扫描程序**： 按键扫描程序是嵌入式...
DAY16. 轮询与中断作业
08-16
在Linux系统中，轮询和中断是两种常见的输入/输出(I/O)处理机制。在"DAY16. 轮询与中断作业"这个主题中，我们将深入探讨这两种方法，并结合实际例子——通过轮询检测Key3按键状态来控制LED2的亮灭，来理解它们的工作...
轮询-中断-DMA-通道1
08-08
本文主要介绍了三种常见的I/O管理方式：轮询、中断和直接内存存取（DMA）方式，以及通道方式。 一、轮询方式 轮询是一种早期的I/O管理方式，处理机定期检查每个设备，看是否有数据需要处理。这种方式简单，但由于...
单片机中断与CPU的轮询有什么区别
07-11
那么，什么是单片机中断，它与CPU的轮询有什么区别？在本文中，单片机开发工程师将对单片机中断和CPU轮询做个简单的介绍。 中断： 中断是一种硬件机制，在这种机制中，设备会通知CPU它需要引起注意。中断可以...
go语言 解决scan空格结束输入的问题。
qqqweiweiqq的博客
07-20 216
go
探索创新：Goscan - 一款强大的Go语言代码扫描工具
最新发布
gitblog_00090的博客
04-12 546
探索创新：Goscan - 一款强大的Go语言代码扫描工具 goscangoscan is a simple and efficient IPv4 network scanner that discovers all active devices on local subnet.项目地址:https://gitcode.com/gh_mirrors/gos/goscan 是一个开源项目，旨在帮助...
串口驱动研究
塔通天的博客
02-01 1319
文章目录串口驱动研究1、串口硬件研究1.1、串口三个模式1.2、普通串口模式研究1.2.1、FIFO management1.2.1.1、FIFO中断模式1.2.1.2、FIFO轮询模式1.2.1.3、FIFO DMA模式1.2.2、 模式选择1.2.3、协议格式1.3、串口编程模型2、串口驱动流程2.1、第一阶段流程2.2、第二阶段流程 串口驱动研究 1、串口硬件研究 1.1、串口三个模式 （1）Uart模式 普通的串口模式，在普通串口模式下，具有自动请求发送（RTS）、自动清除发送（CTS）等功能，这里
Go语言中 Scan 与 Scanf 和 Scanln的区别
了 凡
01-18 4772
三种输入函数的区别 首先它们都是在fmt包下的三个扫描函数，类似于java中是Scanner一样，在Go语言中使用&取值指针来进行获值 第一种：fmt.Scan 输入：读取以空白符分割的值返回到地址中进行修改，换行视为空白符 返回值：错误处理，返回值中有一个int类型的值是返回正确的数量，有一个err是错误的原因 var ( // 定义全局变量 name int age int married int ) ag1, err := fmt.Scan(&amp
中断方式与轮询方式
冰源
08-13 2781
中断方式与轮询方式 中断的基本概念 程序中断通常简称中断，是指CPU在正常运行程序的过程中，由于预选安排或发生了各种随机的内部或外部事件，使CPU中断正在运行的程序，而转到为相应的服务程序去处理，这个过程称为程序中断。 二、80x86微处理器的中断 80x86微处理器的中断类型一般分为2类，即由于执行某些指令引起的软中断和由处理器以外其他控制电路发出中断请求信号引起的硬中断。 CPU要从主...
go fmt.Scan Scanf Scanln的一个小问题
一个程序员的琐碎
08-22 7866
bug记录 Scan,Scanf,Scanln的一个问题 go的fmt.Scan在使用中的一个小问题，如下： for{ fmt.Println("请选择：1-剪刀 2-石头 3-布 ，0-不玩了") count, err := fmt.Scan(&amp;people) if err != nil { fmt.Println(err) ...
go语言scan空值报错
leonpengweicn的专栏
04-19 7699
http://xmarker.blog.163.com/blog/static/22648405720144743531420/ 今天使用go语言时，如果数据库里有空值，扫描出来报错，其中环境是这样的，数据库为postgresql9.3.2（其实和数据库无关），数据库里的数据如下： db_public=> \d t_tmp              Table "usr_publ
标准库 - fmt/scan.go 解读
weixin_30699235的博客
09-20 237
// Copyright 2010 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // go/src/fmt/scan.go // version 1....
Go语言：解决数据库中null值的问题
热门推荐
绯浅yousa的笔记
12-12 5万+
Go语言：解决数据库中null值的问题 本文主要介绍如何使用go语言database/sql库从数据库中读取null值的问题，以及如何向数据库中插入null值。本文在这里使用的是sql.NullString, sql.NullInt64, sql.NullFloat64等结构体，为了方便书写，它们的泛指我会使用sql.Null***来表示 要点 从数据库读取可能为null值得值时，可以选择使用s
6410中断机制解析：从轮询到中断驱动
中断机制的主要优势在于其高效性，与轮询机制相比，中断能够避免不必要的CPU资源浪费。在轮询中，CPU需要不断检查外设状态，而中断则允许CPU在没有外设请求时全速执行任务，只有在真正需要时才暂停当前任务，处理...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值