golang中实现并发非常简单，只需在需要并发的函数前面添加关键字＂go"，但是如何处理go并发机制中不同goroutine之间的同步与通信，golang 中提供了sync包和channel机制来解决这一问题． sync 包提供了互斥锁这类的基本的同步原语.除 Once 和 WaitGroup 之外的类型大多用于底层库的例程。更高级的同步操作通过信道与通信进行。 type Cond func NewCond(l Locker) *Cond func (c *Cond) Broadcast() func (c *Cond) Signal() func (c *Cond) Wait()type Lockertype Mutex func (m *Mutex) Lock() func (m *Mu...阅读全文
如果不是我对真正并行的线程的追求，就不会认识到Go有多么的迷人。 Go语言从语言层面上就支持了并发，这与其他语言大不一样，不像以前我们要用Thread库 来新建线程，还要用线程安全的队列库来共享数据。 以下是我入门的学习笔记。 Go语言的goroutines、信道和死锁 goroutine Go语言中有个概念叫做goroutine, 这类似我们熟知的线程，但是更轻。 以下的程序，我们串行地去执行两次loop函数: func loop() { for i := 0; i < 10; i++ { fmt.Printf("%d ", i) } } func main() { loop() loop() } 毫无疑问，输出会是这样的: 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 ...阅读全文
channels 是 goroutines之间通信的工具， 可以理解为管道， 虽然go也提供共享变量的方式， 但是更加推荐使用channel func TestChan(t *testing.T) { c := make(chan int) go func() { c <- 48 }() fmt.Println(<- c) // 保持持续运行 holdRun() } func holdRun() { time.Sleep(1 * time.Hour) } c := make(chan int) 声明一个 传输整形 的unbuffer chan,（接收消息和发送消息者将会阻塞，直到channel ”可用“） <- 操作符用来接受和发送消息 chan <- 48 发送“48“ 进入管道， <-c...阅读全文
欢迎来到 [Golang 系列教程](https://studygolang.com/subject/2)的第 24 篇。 ## 什么是 select？ `select` 语句用于在多个发送/接收信道操作中进行选择。`select` 语句会一直阻塞，直到发送/接收操作准备就绪。如果有多个信道操作准备完毕，`select` 会随机地选取其中之一执行。该语法与 `switch` 类似，所不同的是，这里的每个 `case` 语句都是信道操作。我们好好看一些代码来加深理解吧。 ## 示例 ```go package main import ( "fmt" "time" ) func server1(ch chan string) { time.Sleep(6 * time.Second) ch <-...阅读全文
go提供了sync包和channel来解决协程同步和通讯。新手对channel通道操作起来更容易产生死锁，如果时缓冲的channel还要考虑channel放入和取出数据的速率问题。 从字面就可以理解，sync.WaitGroup是等待一组协程结束。它实现了一个类似任务队列的结构，你可以向队列中加入任务，任务完成后就把任务从队列中移除，如果队列中的任务没有全部完成，队列就会触发阻塞以阻止程序继续运行。 sync.WaitGroup只有3个方法，Add()，Done()，Wait()。 其中Done()是Add(-1)的别名。简单的来说，使用Add()添加计数，Done()减掉一个计数，计数不为0, 阻塞Wait()的运行。 简单示例如下： package main import ( "fmt"...阅读全文
通道类型是Go自带的，相当于是一个先进先出的队列，同时唯一一个可以满足并发安全性的类型。声明一个通道类型变量的时候，首先需要确定通道类型的元素类型,然后还要确定通道的容量，当然默认容量是0。 初始化 使用make进行初始化,如下所示： c := make(chan int) c := make(chan string, 10) 如果不指定容量，默认通道的容量是0，这种通道也成为非缓冲通道。 通道的发送和接收特性 对于同一个通道，发送操作之间是互斥的，接收操作之间也是互斥的。 简单来说就是在同一时刻，Go的运行系统只会执行对同一个通道的任意个发送操作中的某一个，直到这个元素值被完全复制进该通道之后，其他发送操作才会执行。针对接收操作也是这样。 对于通道中的同一个值，发送操作和接收操作也是互斥的...阅读全文
在实际业务场景中，为了提高系统的实时性，减轻日志存储压力，需要将日志直接生产至消息中间件，减少flume或flumted收集所导致的延时及性能压力，本文实现了一下功能：实现了一个静态调用的异步生产者 AsyncProducer封装了一个用于异步发送的生产器 Agent//@description kafka代理 //@author chenbintao //@data 2017-09-27 10:30 初稿 // 2017-09-27 11:15 规范代码 // 2017-09-28 14:15 对发送逻辑进行了优化 package kafkaAgent import ( "fmt" "log" "runtime/debug" "strings" "time" "github.com/Sho...阅读全文
直接上代码： 1. 第一种情况， 如果没有select{}， main 主线程不会等待coroutine运行，导致coroutine得不到机会运行。 You are requesting eventual scheduling (using the two go statements) of two goroutines and then you exit main without giving the scheduler a chance to do anything. 有了select， 程序正常运行。 package main import ( "fmt" "time" ) func main() { go func1() go func2() select{} } func func...阅读全文
1 解释上回学习的谜团 # src/main/blocking3.go package main import ( "fmt" ) func f1(in chan int) { number := <- in fmt.Println(number) } func main() { out := make(chan int) out <- 2 go f1(out) fmt.Println("end") } go run blocking3.go fatal error: all goroutines are asleep - deadlock! goroutine 1 [chan send]: main.main() 只需要把 go f1(out) 和 out <-2 对换一下就可以了 # s...阅读全文
在 Go 编程语言中，channel 是一个闪耀的特性。它提供了一种强大的、在不使用锁或临界区的情况下，从某个 goroutine 向其他 goroutine 发送数据流的方法。今天我想讨论关于 channel 的两个重要的特性，这些特性不但使其在控制数据流方面极为有用，而且用在流程控制方面也十分有效。 一个已经被关闭的 channel 永远都不会阻塞第一个特性，我想谈一谈已经被关闭的 channel。当一个 channel 一旦被关闭，就不能再向这个 channel 发送数据，不过你仍然可以尝试从 channel 中获取值。package main import"fmt" func main() { ch := make(chan bool, 2) ch <- true ch <- tru...阅读全文
几周前我们分享了一个帖子讲述我们为什么选择Go语言编写CockroachDB，我们收到一些问题，询问我们是如何解决Go语言的一些已知问题，特别是关于性能、GC和死锁的问题。 本文中我们将分享几个非常有用的优化技巧用以改善许多常见的GC性能问题（接下来还将覆盖一些有趣的死锁问题）。我们将重点分享如何通过嵌套结构体、使用 sync.Pool、和复用后端数组减少内存分配和降低GC开销。 减少内存分配和GC优化 将Go与其他语言（比如java）区别开来的是Go语言能让你管理内存布局。通过GO语言，你可以合并碎片，而其他垃圾集合语言不能。 让我们看看CockroachDB中从磁盘读取数据并解码的一小段代码： metaKey := mvccEncodeMetaKey(key) var meta MVCC...阅读全文
本文我们来学习一下golang里面的并发以及golang的锁机制。 首先我们假设这样一个场景，有两个协程，同时在读写一个数字，分别对其进行递增和递减，代码如下。 func main(){ a := 1 p_a := &a go func(p_a *int){ for i := 1; i < 100000; i++ { *p_a += 1 fmt.Println(*p_a) } }(p_a) go func(p_a *int){ for i := 1; i < 100000; i++ { *p_a -= 1 fmt.Println(*p_a) } }(p_a) } 运行这段代码我们发现什么都没有输出，原因很简单，主程序在创建完两个协程之后就退出了。要想让主程序不退出可以使用sync.WaitG...阅读全文
GoLang中控制并发有两种方式: sync.WaitGroup 和 channel 下面是两种方法的对比 sync.WaitGroup，该方法最大优点是Wait()可以阻塞到队列中的所有任务都执行完才解除阻塞，但是它的缺点是不能够指定并发协程数量． channel优点：能够利用带缓存的channel指定并发协程goroutine，比较灵活．但是它的缺点是如果使用不当容易造成死锁；并且他还需要自己判定并发goroutine是否执行完． 但是相对而言，channel更加灵活，使用更加方便，同时通过超时处理机制可以很好的避免channel造成的程序死锁，因此利用channel实现程序并发，更加方便，更加易用...阅读全文
最近看了下Go语言并写了些示例代码，在用到channel的时候报了个奇怪的错误然后退出： "fatal error: all goroutines are asleep - deadlock!" 在stackoverflow上搜到：http://stackoverflow.com/questions/8246065/all-goroutines-are-asleep-deadlock-error 查了查，出错的代码如下： func chanFunc(c chan int, d chan int) { i := 0 for { select { case v, ok := <- c: if ok { fmt.Printf("channel c get %d\n", v) c <- v i++ ...阅读全文
部分理解：关于channel 和 goroutine 例子package main import "strconv" import "fmt" func main() { //在主goroutine中要先有读取chan的请求，之后才可以赋值，即有需求才会有chan赋值的举动，否则先别碰chan，不然会死锁 //1 taskChan := make(chan string, 3) doneChan := make(chan int, 1) for i := 0; i < 3; i++ { taskChan <- strconv.Itoa(i) fmt.Println("send: ", i) } go func() { for i := 0; i < 3; i++ { task := <-ta...阅读全文
如果不是我对真正并行的线程的追求，就不会认识到Go有多么的迷人。 Go语言从语言层面上就支持了并发，这与其他语言大不一样，不像以前我们要用Thread库 来新建线程，还要用线程安全的队列库来共享数据。 以下是我入门的学习笔记。 首先，并行!=并发, 两者是不同的，可以参考:http://concur.rspace.googlecode.com/hg/talk/concur.html Go语言的goroutines、信道和死锁 goroutine Go语言中有个概念叫做goroutine, 这类似我们熟知的线程，但是更轻。 以下的程序，我们串行地去执行两次loop函数: func loop() { for i := 0; i < 10; i++ { fmt.Printf("%d ", i) }...阅读全文
Goroutine和channel是Go在“并发”方面两个核心feature。我自己在使用golang开发时会被常会被channel所困扰。废话不多说，正题开始. 那么golang的channel是什么？ 简单说他可以让goroutine之间互相通信，通俗讲我可以通过channel传递信息给goroutine。 我可以通过channel来控制调度goroutine。 那么channel有几个分类？ 对于golang的channel的基础我还是有些了解的，channel主要有两类，一类是无缓冲，一类是有缓冲 。 Python 缓冲信道: var ch chan int = make(chan int, 2) 无缓冲信道: var ch chan int = make(chan int) 123...阅读全文
性能，HA (高可用)，运维等等 「对于一个设计良好的分布式系统来说，单机性能从来不是一个问题 」—— 我 第一篇文章就说了，Codis 采用了 Proxy 的方案，所以必然会带来单机性能的损失，经测试，在不开 pipeline 的情况下，大概会损失 40% 左右的性能，但是 Redis 本身是一个快得吓人的东西，即使单机损失了 40% 仍然是一个很大的数字。 另外一个比较好的地方是，Codis 本身是可以充分的利用多核的（Thanks to golang），在多线程客户端的环境下，不会像 Twemproxy 那样，撑死就跑满一个 CPU（当然你可以部署 Twemproxy 的多实例，但不就又增加运维成本了嘛。。。）。而且不要忘了， Codis 可以通过平行扩展多个 Proxy 实现性能成倍...阅读全文
如果不是我对真正并行的线程的追求，就不会认识到Go有多么的迷人。 Go语言从语言层面上就支持了并发，这与其他语言大不一样，不像以前我们要用Thread库 来新建线程，还要用线程安全的队列库来共享数据。 以下是我入门的学习笔记。 首先，并行!=并发, 两者是不同的，可以参考:http://concur.rspace.googlecode.com/hg/talk/concur.html Go语言的goroutines、信道和死锁 goroutine Go语言中有个概念叫做goroutine, 这类似我们熟知的线程，但是更轻。 以下的程序，我们串行地去执行两次loop函数: func loop() { for i := 0; i < 10; i++ { fmt.Printf("%d ", i) }...阅读全文
goroutine之间的同步 goroutine是golang中在语言级别实现的轻量级线程，仅仅利用go就能立刻起一个新线程。多线程会引入线程之间的同步问题，经典的同步问题如生产者-消费者问题，在c，java级别需要使用锁、信号量进行共享资源的互斥使用和多线程之间的时序控制，而在golang中有channel作为同步的工具。 1. channel实现两个goroutine之间的通信 package main import "strconv" import "fmt" func main() { taskChan := make(chan string, 3) doneChan := make(chan int, 1) for i := 0; i < 3; i++ { taskChan <- ...阅读全文
直接上代码：1. 第一种情况， 如果没有select{}， main 主线程不会等待coroutine运行，导致coroutine得不到机会运行。You are requesting eventual scheduling (using the two go statements) of two goroutines and then you exit main without giving the scheduler a chance to do anything. 有了select， 程序正常运行。[plain] view plaincopyprint?package main import ( "fmt" "time" ) func main() { go func1() go fun...阅读全文
首先，并行!=并发, 两者是不同的 Go语言的goroutines、信道和死锁 goroutine Go语言中有个概念叫做goroutine, 这类似我们熟知的线程，但是更轻。 以下的程序，我们串行地去执行两次loop函数: func loop() { for i := 0; i < 10; i++ { fmt.Printf("%d ", i) } } func main() { loop() loop() } 毫无疑问，输出会是这样的: 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 下面我们把一个loop放在一个goroutine里跑，我们可以使用关键字go来定义并启动一个goroutine: func main() { go loop() // 启动一个...阅读全文
Go语言的一个很大的优势就是内置了goroutine机制，使得开发者可以方便地编写并发程序。 在去年的Google I/O大会上，Go语言开发团队成员Rob Pike介绍了Go的并发模式。如今该语言已经到达了1.1版本，性能和安全性较之以前更加完善。在本月举行的I/O 2013上，团队成员Sameer Ajmani带来了更高级的Go语言并发模式演讲，以帮助开发者更深入地了解Go语言的并发编程问题。 你可以通过这个幻灯片来查看：https://talks.golang.org/2013/advconc.slide（使用左右方向键翻页，点击代码页的run按钮可直接运行代码，你还可以直接对代码进行修改） 在幻灯片中，Sameer介绍了如何检测和避免死锁、竞争条件（race conditions），...阅读全文
发起了4个这样的客户端，分为两组，这两组是一模一样的， 运行大概20分钟死锁了...阅读全文
一面hashmap与concurrenthashmap的区别垃圾回收算法以及垃圾回收器CMS的回收步骤G1和CMS的区别CMS哪个阶段是并发的哪个阶段是串行的？G1内部是如何分区的（region）HashMap如何解决Hash冲突my sql 索引类别什么是覆盖索引b+树和b树的区别为什么选用自增量作为主键索引my sql如何优化查询my sql如何在RR隔离级别下避免幻读问题：间隙锁my sql范式和反范式的区别以及彼此的优缺点AOF如何缩减自身文件大小AOF缩减自身文件大小的时候，数据库来了新的操作怎么办？多线程了解么？死锁条件以及破坏死锁条件的方法volatile做什么用的，如何实现可见性的volatile和atomic的区别atomic底层是如何实现的二面表锁 行锁 乐观锁 悲观锁的...阅读全文
中文译名 Go 编程 外文原文名 Programming in Go 外文原文版出处 the United States on recycled paper at RR Donnelley in Crawfordsville, Indiana. 译 文： 第七章 并发编程 7.1主要概念 7.2例子 7.2.1:过滤器 7.2.2:并发查找 7.2.3:线程安全表 7.2.4:Apache 报告 7.2.5:找重复 并发编程能够让开发者实现并行算法，以及利用多处理器和多核写程序。但是在大多主流变成语言中（例如C,C++和Java）相对单线程程序，很难实现、维护以及调试并发程序。进一步的，并不总是可能分开处理、值得去使用多线程。无论如何，由于线程本身的开销或者仅仅因为更容易在多线程程序中出错，...阅读全文
简单使用： package main import ( "sync" ) type httpPkg struct{} func (httpPkg) Get(url string) {} var http httpPkg func main() { var wg sync.WaitGroup var urls = []string{ "http://www.golang.org/", "http://www.google.com/", "http://www.somestupidname.com/", } for _, url := range urls { // Increment the WaitGroup counter. wg.Add(1) // Launch a goroutine ...阅读全文
源码级剖析Go标准库中的sync.RWMutex。 概述RWMutex，读写锁，又称“读写互斥锁”。读写锁简单来说就是可以由任意数量的读者同时使用，或者只由一个写者使用的锁。 读写锁和互斥量(Mutex)类似，但是比起互斥量有着更高的并行性，它允许多个读者同时读取，因此有一些特殊的应用场景。在并发编程的很多场景下，数据的读取可能比写入更加频繁，这时就要允许多个线程同时读取一块内容。 用例Go中，RWMutex的零值是一个未加锁的互斥量。 RWMutex使用起来相对比较简单，这里举一个简单的例子： 12345678910111213141516171819202122232425262728293031package mainimport ( "fmt" "sync" "time")func ...阅读全文
介绍 Channel 是 Go 语言中被用来实现并行计算方程之间通信的类型。其功能是允许线程间通过发送和接收来传输指定类型的数据。其初始值是 nil。 创建 Channel 创建 Channel 的方法如下： var c1 chan [value type] c1 = make([channel type] [value type], [capacity]) [value type] 定义的是 Channel 中所传输数据的类型。 [channel type] 定义的是 Channel 的类型，其类型有以下三种： “chan” 可读可写——“chan int” 则表示可读写 int 数据的 channel "chan<-" 仅可写——“chan<- float64” 则表示仅可写64位 fl...阅读全文
image 引言 上下文切换（有时也称做进程切换或任务切换）是指 CPU 从一个进程或线程切换到另一个进程或线程。上下文切换会影响多线程执行速度。死锁是指多个进程或线程循环等待它方占有的资源而无限期地僵持下去的局面。 1、上下文切换 上下文定义 cpu发生进程或者线程切换时，所依赖的数据集合，比如一个函数有外部变量，函数运行时，必须获取外部变量，这些变量值的集合就是上下文。 引发问题 对于CPU密集型任务，多线程处理会发生上下文切换，会影响到执行速度，如果时IO密集型，多线程技术优点尽显。 如何减少上下文切换 无锁并发编程，锁的获取与释放会发生上下文切换，多线程时会影响效率。无锁并发编程就是将数据分块，每个线程处理各自模块。比如LongAdder中部分代码。 CAS算法，并发编程时通过CAS...阅读全文
**1**.求两个字符串的交集 ```go package main import "fmt" func main() { str1 :="abcdef" str2 :="hghcdesghv" /* 将字符串遍历，比较字节相同则输出 */ for _,v1:=range str1 { for _,v2:=range str2 { if v1==v2 { fmt.Printf(string(v1)) } } } }``` **2** .未知逻辑运算符优先等级 ```go package main import "fmt" /* 未知 && ||逻辑运算优先级 通过代码求优先级 */ func main() { a :=true b :=false c :=false if a&&b||c{ ...阅读全文
在 Go 编程语言中，channel 是一个闪耀的特性。它提供了一种强大的、在不使用锁或临界区的情况下，从某个 goroutine 向其他 goroutine 发送数据流的方法。 今天我想讨论关于 channel 的两个重要的特性，这些特性不但使其在控制数据流方面极为有用，而且用在流程控制方面也十分有效。 一个已经被关闭的 channel 永远都不会阻塞 第一个特性，我想谈一谈已经被关闭的 channel。当一个 channel 一旦被关闭，就不能再向这个 channel 发送数据，不过你仍然可以尝试从 channel 中获取值。 ```golang package main import "fmt" func main() { ...阅读全文
go 语言的promise异步函数 go 语言的异步书写方式就不再赘述，相关的资料网上有很多。通过一些简单的学习之后，我一直觉使用方式很别扭，比如我想异步并在函数执行之前不退出程序，就需要用在代码中往管道中写值，并读出来值，否则就会死锁。 后来思考之后，试着实现了一个通用的方法，该方法并未实现绝对的通用，但是至少是一个改善的思路。有幸感兴趣的朋友如果恰巧看到该实现，觉得有趣可以一起探讨。 代码如下 promise.go package promise import "sync" type Promise struct { wg sync.WaitGroup } func (p *Promise) Add(f func()) { p.wg.Add(1) go func() { f() ...阅读全文
作者｜许式伟 编辑｜小智 2007 年 9 月 20 日，关于设计一门全新语言的讨论正式开始，这门全新的语言，就是后来的 Go。时至今日，Go 语言已经发布到 1.9 版本，走过了整整十年的历程。在这十年间，Go 语言两夺 TIOBE 年度语言大奖（2009/2016），许多初创公司在早期使用 Go 进行开发，包括现在的云计算巨头 Docker，也由此催生出了 Kubernetes 这样的项目。在大洋彼岸的中国，Google Trends 显示 Go 的异常火爆更让 Go 语言之父感到震惊。而这一切，跟一位名叫许式伟的技术人密不可分。 Go 语言刚刚度过了它的十周年纪念日。而要说我与 Go 的缘分，也同样始于十年前（2007 年）。这十年，是 Go 成长的十年，同样也是我成长的十年。2007...阅读全文
聪明的你，用golang写后端服务，各种使用channel和goroutine，把java要用线程池干的事儿用携程都搞掂了。服务线下运行一切正常，压测，单元测，联调统统通过。你露出得意的微笑，一键发布到生产环境，欣喜的发现服务崩溃了。 为什么服务会崩溃呢？ --------- channel死锁 --------- 死锁是golang里边最常见的一类问题，我们从java和c/c++转过来的gopher在编程时候会特别注意mutex，semaphore，atomic等等的使用，反复检查会不会造成死锁。但是我们有可能会忽略掉另一个死锁大元凶：channel。 channel简直就是用来死锁的。 unbuffered channel读和写都是blocking的，也就是说读一个没人写的channel...阅读全文
运行环境：mac go的版本是1.5 协程中使用time.Sleep的时候造成死锁，麻烦哪位大神给解答下。 代码1: 运行正常 ```go func test_sleep(index int){ for i:=0;i<100;i++{ fmt.Println("index:", index, " i:",i) } wg.Done() } var wg sync.WaitGroup func main(){ runtime.GOMAXPROCS(8) for i:=1;i<11;i++{ wg.Add(1) go test_sleep(i) } wg.Wait() } ``` 代码2: 执行一段时间，就...阅读全文
Go语言的一个很大的优势就是内置了goroutine机制，使得开发者可以方便地编写并发程序。 在去年的Google I/O大会上，Go语言开发团队成员Rob Pike介绍了Go的并发模式。如今该语言已经到达了1.1版本，性能和安全性较之以前更加完善。在本月举行的I/O 2013上，团队成员Sameer Ajmani带来了更高级的Go语言并发模式演讲，以帮助开发者更深入地了解Go语言的并发编程问题。 你可以通过这个幻灯片来查看：https://talks.golang.org/2013/advconc.slide（使用左右方向键翻页，点击代码页的run按钮可直接运行代码，你还可以直接对代码进行修改） 在幻灯片中，Sameer介绍了如何检测和避免死锁、竞争条件（race conditions），...阅读全文
先说说golang的语法吧，个人觉得有以下特点： 简洁，不管是变量、方法声明，还是代码编写，均十分简洁，效率也比较高 非纯粹面向对象，但是go的struct类似c的struct，go的结构体还可以进行struct的包含，被包含的struct的方法被外层struct共享 指针，方法传参时可以直接传指针，相比传值更加快速 接口，go中规定，如果一个对象（struct）实现了interface中的所有方法，那么该struct便实现该接口 chan的定义，用来各个线程（有人叫协程，超轻量级）间的通信，基本不用考虑死锁等问题 。。。 go的特性还有很多，菜鸟就不多说了，下面是一个用go开发的博客应用，功能比较简单，直接上菜： 系统环境 go版本：1.5rc1 系统：win7 数据库：mongodb（使...阅读全文
关于官方的二叉树的经典实现的。如下：   如果有二叉树a,b，b和a的差别就是b的节点 比a多，那a使用的管道能正常关闭，b的使用管道何时关闭？b所在的goroutine何时释放? 个人认为如果出现不匹配，则始终会有管道和goroutine没有释放。 如果要释放资源，目前能想到的办法是给Walker中多传入一个flag管道判断是否需要释...阅读全文
go极简的25个关键字很给力，让程序员把更多的精力投入到业务逻辑上；反观C++各种奇技无穷仍让你多年后还在感叹它的魔力。概念：
并发）：1、多个执行实例在单个CPU上交替进行，在逻辑上表现为同一时刻发生，但在物理上是串行的。
并行）：1、多个执行实例在多个CPU上并行执行。
可以这么理解，并发是一种程序算法实现在单个CPU上模拟同一时刻发生的手段，而并行是物理状态同时发生的。
GO使用CSP（阅读全文
//关于go语言协程通道的使用 //1.通道可以带缓存，也可以不带 //2.不带缓存的，不管是读还是写都会阻塞 //3.带缓存的，如果缓存溢出，就会阻塞 //4.make(chan int,1)和make(chan int)是不一样的，第一种通道内写入两个数据会阻塞，第二种写入就会阻塞 //5.如果协程在阻塞，但是主程已经退出执行，则认为程序死锁 //6.如果程序除了主程之外（没有一个协程），处于阻塞状态，则认为程序死锁 //7.一句话：只有一个协程（可以是主程），在阻塞，认为程序处于死锁 //8.子程序是协程的一种特例，阻塞到子程序执行完毕返回，而协程可能等不到执行完毕就返回，然后条件满足再回来执行 package main import ( "fmt" ) func main() { /...阅读全文
如果不是我对真正并行的线程的追求，就不会认识到Go有多么的迷人。 Go语言从语言层面上就支持了并发，这与其他语言大不一样，不像以前我们要用Thread库 来新建线程，还要用线程安全的队列库来共享数据。 以下是我入门的学习笔记。 首先，并行!=并发, 两者是不同的，可以参考:http://concur.rspace.googlecode.com/hg/talk/concur.html Go语言的goroutines、信道和死锁 goroutine Go语言中有个概念叫做goroutine, 这类似我们熟知的线程，但是更轻。 以下的程序，我们串行地去执行两次loop函数: func loop() { for i := 0; i < 10; i++ { fmt.Printf("%d ", i) }...阅读全文
下面这段代码 在执行的时候直接报错是会发生死锁，程序就报错退出了。请问各位大神死锁原因。 package main import ( "fmt" ) func main() { var ichan chan int ichan = make(chan int) ichan 《- 1 close(ichan) if v, ok := <-ichan; ok { fmt.Println(v) } else { fmt.Println("get chan fail!") } } 注： 上面的代码需要把《字符换做英文版的。 程序报错位置是在 ichan 《- 1这一行，个人对这个程序的理解是，先建立一...阅读全文
在编写 golang 程序的过程中，channel 会经常使用。本文对 channel 的使用的确很特别，同时也非常实用。 原文在此：http://dave.cheney.net/2013/04/30/curious-channels ————翻译分隔线———— 绝妙的 channel 在 Go 编程语言中，channel 是一个闪耀的特性。它提供了一种强大的、在不使用锁或临界区的情况下，从某个 goroutine 向其他 goroutine 发送数据流的方法。 今天我想讨论关于 channel 的两个重要的特性，这些特性不但使其在控制数据流方面极为有用，而且用在流程控制方面也十分有效。 一个已经被关闭的 channel 永远都不会阻塞 第一个特性，我想谈一谈已经被关闭的 channel。当...阅读全文
为什么会出现死锁的问题？ fatal error: all goroutines are asleep - deadlock...阅读全文
[原文地址](https://bingjian-zhu.github.io/2019/09/25/channel%E4%BD%BF%E7%94%A8%E6%8A%80%E5%B7%A7/) #### 前言 Go协程一般使用channel（通道）通信从而协调/同步他们的工作。合理利用Go协程和channel能帮助我们大大提高程序的性能。本文将介绍一些使用channel的场景及技巧 #### 场景一，使用channel返回运算结果 计算斐波那契数列，在学习递归时候这是个经典问题。现在我们不用递归实现，而是用channel返回计算得出的斐波那契数列。 计算前40个斐波那契数列的值，看下效率 ```go package main import ( "fmt" "time" ) //计算斐波那契数列并...阅读全文
因为ip入库时，需要把ip转换成整型，这样比较节约空间，同时搜索比较快，所以代码中需要一个Ip2long函数。项目是一个后台一直执行的任务，不断的接受请求，入库。自己google了一下，在网上找了一段golang版本的Ip2long代码，就在项目中使用了，代码如下： 项目在内网压力测试的过程中，发现执行几个小时后，进程就变成僵尸进程了，进程一直存在，但是就是没有发现在处理数据。重启进程后，发现又能处理数据了。刚开始估计可能是出现死锁了，进程一直在等待，找了很久，也没发现问题。突然去看进程的内存占用，发现高达4-5G，而且内存一直在增加，初步估计是内存泄露吧。go tool pprof分析发现这个函数内存占用超级高： 非常奇怪，为啥一个正则内存占用会这么高？ 修改Ip2long函数如下： 再次...阅读全文
前言: 碰到死锁是一个很让人糟心的事情 ! 更让人无语的事，在测试环境中压力测试了好久都是ok的, 一点毛病都没有。但一到线上的正式环境居然出现死锁了。 主要现象是 队列中的任务不再被消费了，也没有相关的日志输出。 通过我们业务stats接口是可以看到进程内的状态, 队列确实没人消费。 # xiaorui.cc { "alert_queue": 0, "input_task_queue": 30000, // 这个 "notify_queue": 30000, // 这个 "pushing_queue": 0, "qps_boss": { "15m": 189, "1m": 2053, "5m": 541, "avg": 4112, "count": 226029 }, "qps_proxy...阅读全文
事务简单的说，事务就是一组原子性的 SQL 查询，这一组 SQL 要么全部执行成功，要么全部执行失败。这里简单介绍一下事务的 ACID，ACID 表示原子性、一致性、隔离性和持久性。原子性：一个事务是不可分割的最小工作单元，整个事务要么全部成功，要么全部失败，不可能只执行中间的一部分操作。一致性：执行事务是使得数据库从一个一致性状态到另一个一致性状态，如果事务最终没有被提交，那么事务所做的修改也不会保存到数据库中。隔离性：通常来说，一个事务提交之前对其他事务是不可见的，但是这里所说的不可见需要考虑隔离级别，比如未提交读在提交前对于其他事务来说也是可见的，隔离级别，在下面会详细讲。持久性：事务一旦被提交，那么对数据库的修改会被永久的保存，即使数据库崩溃修改后的数据也不会丢失。隔离级别SQL 标...阅读全文
channel用于主进程、协程之间的通信。 1.同步模式channel默认为同步模式，即不创建缓冲区，发送和接收需要一一配对，不然发送方会被一直阻塞，直到数据被接收。需要注意的是，同步的channel不能在一个协程中发送&接收，因为会被阻塞而永远跑不到接收的语句。一个最简单的例子： package main import "fmt" func main() { data := make(chan int) go func() { for d := range data {//通过range不断地处理data fmt.Println(d) } }() data <- 1//发送要放在接收协程跑起来后面，因为发送后会阻塞等待接收 data <- 2 data <- 3 close(data) }...阅读全文
