刚才看golang的sync的包，看见一个很有用的功能。就是WaitGroup。 先说说WaitGroup的用途：它能够一直等到所有的goroutine执行完成，并且阻塞主线程的执行，直到所有的goroutine执行完成。 WaitGroup总共有三个方法：Add(delta int),Done(),Wait()。简单的说一下这三个方法的作用。 Add:添加或者减少等待goroutine的数量 Done:相当于Add(-1) Wait:执行阻塞，直到所有的WaitGroup数量变成0 例子： package main import ( "fmt" "sync" "time" ) func main() { var wg sync.WaitGroup for i := 0; i < 5; i ...阅读全文
chan是一个FIFO队列，chan分成两种类型同步和异步同步的chan完成发送者和接受者之间手递手传递元素的过程，必须要求对方的存在才能完成一次发送或接受异步的chan发送和接受都是基于chan的缓存，但当缓存队列填满后，发送者就会进入发送队列, 当缓存队列为空时，接受者就会接入等待队列。 chan的数据结构: struct Hchan { uintgo qcount; // total data in the q uintgo dataqsiz; // size of the circular q uint16 elemsize; uint16 pad; // ensures proper alignment of the buffer that follows Hchan in mem...阅读全文
os/signal包实现对信号的处理 golang中对信号的处理主要使用os/signal包中的两个方法：一个是notify方法用来监听收到的信号；一个是 stop方法用来取消监听。 func Notify(c chan<- os.Signal, sig ...os.Signal) func Notify(c chan<- os.Signal, sig ...os.Signal)第一个参数表示接收信号的channel, 第二个及后面的参数表示设置要监听的信号，如果不设置表示监听所有的信号。 func main() { c := make(chan os.Signal, 0) signal.Notify(c) // Block until a signal is received. s := ...阅读全文
conn, err := net.DialTimeout("tcp", "192.168.10.46:6000", time.Second) 服务器端没有打开，然后客户端就一直阻塞。求高手指点。谢谢...阅读全文
本博客已迁移至 www.0x520.com 之前用channel练习的时候遇到一个问题，看似好像代码合理，而且编译也不会有问题，但忘记了一个重要的channel特性。 正确的代码: package main import "fmt" func foo(){ defer fmt.Println("World") fmt.Println("Hello") } func sum(x,y int,c chan int){ c <- x + y } func main(){ foo() c := make (chan int); go sum(24,18,c) fmt.Println(<-c); } 如果我把代码改成： package main import "fmt" func foo(){ def...阅读全文
import "os" func main() { for i:=0; i<20; i++ { go func() { for { b:=make([]byte, 10) os.Stdin.Read(b) // will block } }() } select{} } 会产生21个线程： runtime scheduler(src/pkg/runtime/proc.c)会维护一个线程池，当某个goroutine被block后，scheduler会创建一个新线程给其他ready的goroutine GOMAXPROCS控制的是未被阻塞的所有goroutine被multiplex到多少个线程上运...阅读全文
真实的应用场景是：在测试收包的顺序的时候，加了个 tick 就发现丢包了 那么来看一个应用例子： package main import ( "fmt" "runtime" "time" ) func init() { runtime.GOMAXPROCS(runtime.NumCPU()) } func main() { ch := make(chan int, 1024) go func(ch chan int) { for { val := <-ch fmt.Printf("val:%d\n", val) } }(ch) tick := time.NewTicker(1 * time.Second) for i := 0; i < 20; i++ { select { case ch ...阅读全文
1、写go程序的时候一定要牢记主线程不能阻塞，一旦阻塞就崩溃，就怕那种某种情况下偶尔会出现几下阻塞的，一定要杜绝。2、select case的执行顺序是乱的，不确定的3、写入管道的时候，一定要保证管道没有被阻塞写否则会崩溃，读取阻塞管道的时候关闭管道会读取到一个0值和一个false ok...阅读全文
https://www.nginx.com/blog/thread-pools-boost-performance-9x...阅读全文
在实际项目中我们修改了配置文件后，希望在不重启进程的情况下重新加载配置文件，这时候就需要通过信号传递来进行处理了。golang中对信号的处理主要使用os/signal包中的两个方法：一个是notify方法用来监听收到的信号；一个是 stop方法用来取消监听。下面给一个些示例。 监听信号 notify方法原型 func Notify(c chan<- os.Signal, sig ...os.Signal) 第一个参数表示接收信号的管道 第二个及后面的参数表示设置要监听的信号，如果不设置表示监听所有的信号。 package main import ( "fmt" "os" "os/signal" //"syscall" ) func main() { c := make(chan os.Sig...阅读全文
channel是go语言的一大特色，使用原子函数还是使用互斥锁都不如使用channel来的简单，go语言中的channel可以作为函数参数传递和返回值返回，通过发送和接受数据在goroutine之间同步(在学习和使用go语言的时候，我们应该牢记，go语言中所有的结构都是值拷贝的) 本文不对channel使用作讲解，直接上 *酸(dai)菜(ma)* : type hchan struct { qcount uint //队列数据总的数据数量 dataqsiz uint //环形队列的数据大小 buf unsafe.Pointer //指向dataqsiz元素类型大小的数组 elemsize uint16 closed uint32 elemtype *_type // 元素类型 sendx ...阅读全文
项目过程中需要用到golang访问操作zookeeper集群，使用的库是github.com/samuel/go-zookeeper 在使用这个库set数据的时候，有时会出现阻塞，进程执行不下去的问题，有人遇到过么...阅读全文
Goroutines 协程在长期阻塞的状态下怎样跳过阻塞或者终止 协程 如题，我在做tcp服务端发现如果用户端无响应就始终阻塞在读取，无法结束Goroutines ，怎样才能内部或外部停止Goroutine...阅读全文
 看打印日志是 --2 打印了，--3没有打印，然后后续发送消息全部阻塞...阅读全文
在golang中，基本的channel读写操作都是阻塞的，如果你想要非阻塞的，可以使用如下示例： 即只要在select中加入default，阻塞立即变成非阻塞： package main import "fmt" func main() { messages := make(chan string) signals := make(chan bool) select { case msg := <-messages: fmt.Println("received message", msg) default: fmt.Println("no message received") } msg := "hi" select { case messages <- msg: fmt.Println("...阅读全文
使用nsq的时候遇到这样一个问题： AddConcurrentHandlers(handler, 8)的时候，已经有多个协程处理收到的消息。然而，当其中一个handle发生阻塞时，会导致整个Consumer阻塞，runtime.GOMAXPROCS(runtime.NumCPU()) 代码调用了。下面的代码也看不出问题，请教一下为什么会发生阻塞？ ``` // AddConcurrentHandlers sets the Handler for messages received by this Consumer. It // takes a second argument which indicates the number of goroutines to spawn fo...阅读全文
[[翻译]绝妙的 channel by mikespook][1] 一个已经被关闭的 channel 永远都不会阻塞 一个 nil channel 永远都是阻塞的 [1]: http://www.mikespook.com/2013/05/%E7%BF%BB%E8%AF%91%E7%BB%9D%E5%A6%99%E7%9A%84-channel/#more-163...阅读全文
``` func connect_apns(procid int)(error, *tls.Conn){ cert, err := tls.LoadX509KeyPair(certpath, keypath) if err != nil { fmt.Printf("error: %s ,procid:%d\n", err.Error(), procid) return err,nil } // 连接到 APNS conn, err := net.Dial("tcp", "gateway.push.apple.com:2195") if err != nil { fmt.Printf("tcp e...阅读全文
package main import ( "fmt" "time" ) func main() { // Case-1: no buffer //chanMessage := make(chan string) // Case-2: with buffer ... the output changes chanMessage := make(chan string, 2) count := 4 go func() { for i := 1; i <= count; i++ { fmt.Println("send message") // send to chanMessage chanMessage <- fmt.Sprintf("message %d", i) } }() // Paus...阅读全文
现用heap做了一个优先级列队。一个线程写。一个线程读。有数据就读。想用for 循环读不知道如何加个组塞。可以在没有数据时停止。有数据自动读取。 谢谢 ...阅读全文
//阻塞，直到WaitGroup中的所以过程完成。 import ( "fmt" "sync" ) func wgProcess(wg *sync.WaitGroup, id int) { fmt.Printf("process:%d is going!\n", id) //if id == 2 { // return //} wg.Done() } func main() { //var wg sync.WaitGroup wg := new(sync.WaitGroup) for i := 0; i < 3; i++ { wg.Add(1) go wgProcess(wg, i) } wg.Wait() fmt.Println("after wait group") ...阅读全文
服务器：是国外的服务器. 场景:在执行到SendMail函数的时候，呈现了阻塞的状态. 也没有返回error,也没有报错.就是一直阻塞者. 但是在本地的时候，是有效的.我想请问出现这种问题的原因会是哪些...阅读全文
注册任务到调度器里，当任务要执行的时候会使用goroutines调用，这样每个任务都不会发生阻塞。 Golang不仅仅是兼容了linux标准的crontab格式，而且扩展了秒。也就是说正常的crontab是 分 时 小时 月 星期，而robfig cron是 秒 分 时 日 月 星期。 c := cron.New() c.AddFunc("0 30 * * * *", func() { fmt.Println("Every hour on the half hour") }) c.AddFunc("@hourly", func() { fmt.Println("Every hour") }) c.AddFunc("@every 1h30m", func() { fmt.Println("Ev...阅读全文
1. io是阻塞的 导致类似 公频聊天一对多的时候 write 到所有用户的时候 等等待所有写入完成 函数才执行完毕 要么就模拟一个异步 但是目前为止没有找到好的解决方案 2.io是阻塞的 导致conn.Read([]byte) 让我以为是 buf := make([]byte, 2) conn.Read(buf) 要么返回一个错误，要么阻塞直到读到2个byte数据为止 其实有可能会返回 1,ni...阅读全文
```go package main import ( "fmt" "time" ) func main() { var num = 10 var p = &num c := make(chan int) go func() { time.Sleep(time.Second) c <- *p //-----> 11 //c <- num //----->10 }() time.Sleep(2 * time.Second) num++ fmt.Println(<-c) fmt.Println(p) return } ``` 为什么 *p 和num的结果不一...阅读全文
//关于go语言协程通道的使用 //1.通道可以带缓存，也可以不带 //2.不带缓存的，不管是读还是写都会阻塞 //3.带缓存的，如果缓存溢出，就会阻塞 //4.make(chan int,1)和make(chan int)是不一样的，第一种通道内写入两个数据会阻塞，第二种写入就会阻塞 //5.如果协程在阻塞，但是主程已经退出执行，则认为程序死锁 //6.如果程序除了主程之外（没有一个协程），处于阻塞状态，则认为程序死锁 //7.一句话：只有一个协程（可以是主程），在阻塞，认为程序处于死锁 //8.子程序是协程的一种特例，阻塞到子程序执行完毕返回，而协程可能等不到执行完毕就返回，然后条件满足再回来执行 package main import ( "fmt" ) func main() { /...阅读全文
载于公众号：灰子学技术原文链接：https://mp.weixin.qq.com/s/nJRVbhRQCgWHR1eHSfBpFA一、前言介绍：对于Go语言并发通讯，是使用的协程goroutine，而协程之间的通讯采用的是channel。但是channel不管是有缓存的，还是无缓存的都会有阻塞的情况出现，只不过无缓存的阻塞会更加频繁。而协程长时间阻塞了之后，Go语言本身又没有提供这种超时的解决机制，所以开发者需要自己考虑实现这种超时机制。这种超时机制在Go语言中则是使用select来解决的。相关的背景知识：1.Go语言并发篇（一）：之go语句篇：https://mp.weixin.qq.com/s/FD-MP9r5sEn1QYRAYZE_4g2.Go语言之goroutine的调度原理： ht...阅读全文
比如 ```gofunc var c = make(chan int, 1) func test() { for { tmp: <-c fmt.Println("如果c是非阻塞，我会一直被循环打印") } } func main() { c<- 6 //这一步是往管道里写，是非阻塞的，因为设了缓冲 test() //那么从管道里读呢，能直接非阻塞吗，我意思是说即使把缓冲读完了，依旧要非阻塞 } ``...阅读全文
Go 语言中的 channel 是实现 goroutine 间无锁通信的关键机制，他使得写多线程并发程序变得简单、灵活、触手可得。下面就个人理解对 channel 使用过程中应该注意的地方进行一个简要的总结。 channel 分类： 不带缓存 channel， 带缓存 channel （1）不带缓存 channel 语法： （a）创建channel make(chan type) e.g. ch := make(chan int) （b）通信方式(由于chan操作类似于Queue，为便于理解这里用EnQueue,DeQueue来描述通信操作) EnQueue: ch <- typevar DeQueue: var := <- ch e.g. ch <- 1 v := <-ch 关键： 调用c...阅读全文
参考：https://segmentfault.com/a/1190000017866100 package main import ( "fmt" "net/http" "time" "context" "sync" ) var Status map[string](chan string) = make(map[string](chan string)) var Timeout = 1000 var Mutex sync.Mutex func Get(w http.ResponseWriter, r *http.Request) { key, ok := r.URL.Query()["key"] fmt.Println(key[0]) if !ok || len(key) < 1 { f...阅读全文
自公众号：灰子学技术原文链接：https://mp.weixin.qq.com/s/PIb-gGBootc6581pHhi5ew学习channel的时候，笔者问了自己几个问题，个人觉得弄明白了这些问题，至少应该会使用channel了。本文也会从这些问题着手，来讲解channel。问题1: 什么是channel?是用来做什么的？1.channel是Go里面的一种类型，它是Go语言为goroutine提供的一种通讯机制，不同的goroutine需要通过channel来相互通讯。2.channel是有类型的，并且还有方向，可以是单向的，也可以是双向的，类似与unix中的pipe(管道)。3.channel是通过<-和->来完成读写操作的，channel<-value（表示往channel写数据），...阅读全文
package main import "fmt" func worker(start chan int, index int) { start <- index fmt.Println("This is Worker:", index) } func main() { start := make(chan int, 5) for i := 1; i <= 10; i++ { go worker(start, i) } /* //用这种方法没有问题 for j := 1; j <= 10; j++ { <-start } */ for v := range start {...阅读全文
我在程序里启动了http服务，监听端口8888，用于接收信息，本希望启动http后再执行其他的代码，但是程序执行了ListenAndServe后，后面的代码没有执行，好像都阻塞在ListenAndServe了，请高手帮忙。。。 ```go func main() { logger.Println("start .....") http.ListenAndServe(":8888", nil) fmt.Println("hello") } ``` ...阅读全文
import "os" func main() { for i:=0; i<20; i++ { go func() { for { b:=make([]byte, 10) os.Stdin.Read(b) // will block } }() } select{} } 会产生21个线程： runtime scheduler(src/pkg/runtime/proc.c)会维护一个线程池，当某个goroutine被block后，scheduler会创建一个新线程给其他ready的goroutine GOMAXPROCS控制的是未被阻塞的所有goroutine被multiplex到多少个线程上运...阅读全文
// select.go package main import ( "fmt" "time" //"time" ) func main() { //声明一个channel ch := make(chan int) //声明一个匿名函数，传入一个参数整型channel类型ch go func(ch chan int) { ch <- 1 //往channel写入一个数据，此时阻塞 }(ch) //由于goroutine执行太快，先让它sleep 1秒 time.Sleep(time.Second) select { //读取ch，解除阻塞 case <-ch: fmt.Print("come to read ch!") default: fmt.Print("come to default!...阅读全文
阻塞场景 无论是有缓存通道、无缓冲通道都存在阻塞的情况。 无缓冲通道的特点是，发送的数据需要被读取后，发送才会完成，它阻塞场景： 1)通道中无数据，但执行读通道。 2)通道中无数据，向通道写数据，但无协程读取。 有缓存通道的特点是，有缓存时可以向通道中写入数据后直接返回，缓存中有数据时可以从通道中读到数据直接返回，这时有缓存通道是不会阻塞的，它阻塞场景是： 1)通道的缓存无数据，但执行读通道。 2)通道的缓存已经占满，向通道写数据，但无协程读。 使用default实现的无阻塞通道阻塞有一个缺陷：当通道不可读或写的时候，会即可返回。实际场景，更多的需求是，我们希望尝试读一会数据，或者尝试写一会数据，如果实在没法读写再返回，程序继续做其它的事情。 使用定时器替代default可以解决这个问题，给...阅读全文
golang 的 select 的功能和 select, poll, epoll 相似， 就是监听 IO 操作，当 IO 操作发生时，触发相应的动作。 示例： ch1 := make (chan int, 1) ch2 := make (chan int, 1) ... select { case <-ch1: fmt.Println("ch1 pop one element") case <-ch2: fmt.Println("ch2 pop one element") } 注意到 select 的代码形式和 switch 非常相似， 不过 select 的 case 里的操作语句只能是【IO 操作】 。 此示例里面 select 会一直等待等到某个 case 语句完成， 也就是等到成功从...阅读全文
image.png TCP/IP(Transmission Control Protocol/Internet Protocol) 即传输控制协议/网间协议，是一种面向连接（连接导向）的、可靠的、基于字节流的传输层（Transport layer）通信协议，因为是面向连接的协议，数据像水流一样传输，会存在黏包问题。 我们先看看项目结构 ├── demo │ └── zinxv0.1 │ └── Server.go ├── go.mod ├── ziface │ └── IServer.go └── znet └── server.go 我们先在定义一个Iserver.go的服务接口,我们需要启动服务器，所以在这个接口里面需要实现3个方法。 package ziface //定义一个服务器接口...阅读全文
RH124系列课程的目标： 1、获得 Redhat 或者 centos 上执行核心系统管理任务所需的足够技能。 2、掌握 RHCSA 认证红帽企业 Linux 系统管理员所需的基本技能。 本章的目标：评估和控制 Red Hat Enterprise Linux 系统上运行的进程。 列举和解释系统中运行的进程的基本信息。 使用bash 作业控制，控制 shell 会话中的进程。 是什么进程？ 所谓进程，它是已启动的可执行程序的运行中的实例。进程有以下组成部分： 已分配内存的地址空间； 安全属性，包括所有权凭证和特权； 程序代码的一个或多个执行线程； 进程状态 进程的环境包括： 本地和全局变量； 当前调度上下文； 分配的资源，如文件描述符和网络端口。 现有进程重复其自己的地址空间(fork)来创...阅读全文
我在看go并发编程的时候说管道是阻塞的,必须并发读写,可是我顺序执行也没什么问题,为什么? ![8974B3A3-05CD-494B-BCD4-68F87C1C89C6.png](https://static.studygolang.com/180228/e7def114f3ea4bfd9b7987ce494b5b37.png...阅读全文
1、未初始化的channel读，阻塞 package main import ( "fmt" "time" ) func main() { var ch chan int go check(ch) fmt.Println("main runtime end") time.Sleep(time.Second * 1000) } func check(ch chan int) { select { case i := <-ch: fmt.Println("read ch data=", i) } fmt.Println("check runtime exit") } 2、未初始化的channel写，阻塞 package main import ( "fmt" "time" ) func main...阅读全文
阻塞式channel 和非阻塞式channel 的使用场景分别有什...阅读全文
1 go的select配合chan 使用使用方式和switch 相似.要求是case 后面的操作必须是chan的读取 //下面这个select会选择default.因为前两个都走不通 //如果没有default 会一直循环case从上到下知道有通道 能读写. var ch1 chan int var ch2 chan int var ch3 []chan int =[] chan int{ch1,ch2} var numbers=[]int{1,2,3,4,5} func main(){ select { case getchan(0)<-getnumber(0): //向未被初始化的通道发送数据会造成当前的g永久的阻塞 fmt.Println("哈哈") case getchan(1)<-...阅读全文
载豆瓣http://www.douban.com/note/484590266...阅读全文
package main import ( "fmt" "time")func main(){ println(time.Now().Unix()) t := time.NewTimer(time.Second*5) //第一次设置 time.Sleep(time.Second*6) //等待超时 //上次t超时所以,t.Reset返回false,t.C 中有第一次设置时的当前时间 if !t.Reset(time.Second*7) { tt:=<-t.C fmt.Println(tt.Unix()) } select { case tt:=<-t.C: fmt.Println(tt.Unix()) fmt.Println("what the screte") } fmt.Println(...阅读全文
package main import ( "fmt" ) func files(fs []string) <-chan string{ c := make(chan string, 1000) //带1000个缓冲的channel,1000个以内不会阻塞 go func(){ for _, f := range fs{ c <- f } close(c) //切片内所有文件发送完毕，关闭 }() return c } func filterSize(in <-chan string) <-chan string{ c := make(chan string, 1000) //带1000个缓冲的channel,1000个以内不会阻塞 go func (){ for i := range in...阅读全文
```go package main import "fmt" import "sync" func main(){ var wg sync.WaitGroup wg.Add(1) f(wg) wg.Wait() fmt.Println("exit from main") } func f(wg sync.WaitGroup){ defer func(){ if e := recover(); e != nil { fmt.Println("caught panic") } wg.Done() }() go func(){ defer func(){ if e := recover(); e !=...阅读全文
特性 nil的通道永远阻塞，即不执行。 break跳出for？ select{}阻塞。 select应用场景 无阻塞的读、写通道 给某个请求/处理，设置超时时间，一旦超时时间内无法完成，则停止处理 有多个通道需要处理，哪个可以处理，就处理哪个 并发系列文章推荐 Golang并发模型：轻松入门流水线模型 Golang并发模型：轻松入门流水线FAN模式 Golang并发模型：并发协程的优雅退...阅读全文
