建设大型网站,wordpress 数据库清空,wordpress 漂浮,商城网站开发哪家好并发是一个很酷的话题#xff0c;一旦你掌握了它#xff0c;就会成为一笔巨大的财富。说实话#xff0c;我一开始很害怕写这篇文章#xff0c;因为我自己直到最近才对并发性不太适应。我已经掌握了基础知识#xff0c;所以我想帮助其他初学者学习Go的并发性。这是众多并发…并发是一个很酷的话题一旦你掌握了它就会成为一笔巨大的财富。说实话我一开始很害怕写这篇文章因为我自己直到最近才对并发性不太适应。我已经掌握了基础知识所以我想帮助其他初学者学习Go的并发性。这是众多并发性教程中的第一篇请继续关注更多的教程。
什么是并发性为什么它很重要
并发是指在同一时间运行多个事物的能力。你的电脑有一个CPU。一个CPU有几个线程。每个线程通常一次运行一个程序。当我们通常写代码时这些代码是按顺序运行的也就是说每项工作都是背对背运行的。在并发代码中这些工作是由线程同时运行的。 一个很好的比喻是对一个家庭厨师的比喻。我还记得我第一次尝试煮意大利面的时候。我按照菜谱一步步地做。我切了蔬菜做了酱汁然后煮了意大利面条再把两者混合起来。在这里每一步都是按顺序进行的所以下一项工作必须等到当前工作完成后才能进行。 快进到现在我在烹饪意大利面条方面变得更有经验。我现在先开始做意大利面然后在这期间进行酱汁的制作。烹饪时间几乎减少到一半因为烹饪意大利面条和酱汁是同时进行的。
并发性与平行性
并发性与并行性有些不同。并行性与并发性类似即同时发生多项工作。然而在并行性中多个线程分别在进行不同的工作而在并发性中一个线程在不同的工作之间游走。 因此并发性和并行性是两个不同的概念。一个程序既可以并发地运行也可以并行地运行。你的代码可以按顺序写也可以按并发写。该代码可以在单核机器或多核机器上运行。把并发性看作是你的代码的一个特征而把并行性看作是执行的一个特征。
Goroutines, the worker Mortys
Go使编写并发代码变得非常简单。每个并发的工作都由一个goroutine来表示。你可以通过在函数调用前使用go关键字来启动一个goroutine。看过《瑞克和莫蒂》吗想象一下你的主函数是一个Rick他把任务委托给goroutine Mortys。 让我们从一个连续的代码开始。
package mainimport (fmttime
)func main() {simple()
}func simple() {fmt.Println(time.Now(), 0)time.Sleep(time.Second)fmt.Println(time.Now(), 1)time.Sleep(time.Second)fmt.Println(time.Now(), 2)time.Sleep(time.Second)fmt.Println(done)
}
2022-08-14 16:22:46.782569233 0900 KST m0.000033220 0
2022-08-14 16:22:47.782728963 0900 KST m1.000193014 1
2022-08-14 16:22:48.782996361 0900 KST m2.000460404 2
done
上面的代码打印出当前时间和一个字符串。每条打印语句的运行时间为一秒。总的来说这段代码大约需要三秒钟的时间来完成。
现在让我们把它与一个并发的代码进行比较。
func main() {simpleConc()
}func simpleConc() {for i : 0; i 3; i {go func(index int) {fmt.Println(time.Now(), index)}(i)}time.Sleep(time.Second)fmt.Println(done)
}
2022-08-14 16:25:14.379416226 0900 KST m0.000049175 2
2022-08-14 16:25:14.379446063 0900 KST m0.000079012 0
2022-08-14 16:25:14.379450313 0900 KST m0.000083272 1
done
上面的代码启动了三个goroutines分别打印当前时间和i。这段代码花了大约一秒钟完成。这比顺序版本快了三倍左右。
等一下我听到你问。为什么要等整整一秒难道我们不能删除这一行以使程序尽可能快地运行吗好问题!让我们看看会发生什么。
func main() {simpleConcFail()
}func simpleConcFail() {for i : 0; i 3; i {go func(index int) {fmt.Println(time.Now(), index)}(i)}fmt.Println(done)
}done嗯…。程序确实在没有任何慌乱的情况下退出了但我们缺少来自goroutines的输出。为什么它们被跳过 这是因为在默认情况下Go并不等待goroutine的完成。你知道main也是在goroutine里面运行的吗主程序通过调用simpleConcFail来启动工作程序但它在工作程序完成工作之前就退出了。
让我们回到烹饪的比喻上。想象一下你有三个厨师他们分别负责烹饪酱料、意大利面和肉丸。现在想象一下如果戈登-拉姆齐命令厨师们做一盘意大利面条和肉丸子。这三位厨师将努力工作烹制酱汁、意大利面条和肉丸。但是在厨师们还没有完成的时候戈登就按了铃命令服务员上菜。很明显食物还没有准备好顾客只能得到一个空盘子。
这就是为什么我们在退出节目前等待一秒钟。我们并不总是确定每项工作都会在一秒钟内完成。有一个更好的方法来等待工作的完成但我们首先需要学习另一个概念。
总结一下我们学到了这些东西
工作被委托给goroutines。使用并发性可以提高你的性能。主goroutine默认不等待工作goroutine完成。我们需要一种方法来等待每个goroutine完成。
Channels, the green portal
goroutines之间是如何交流的当然是通过通道。通道的作用类似于门户。你可以通过通道发送和接收数据。下面是你如何在Go中制作一个通道。
ch : make(chan int)每个通道都是强类型的并且只允许该类型的数据通过。让我们看看我们如何使用这个。
func main() {unbufferedCh()
}func unbufferedCh() {ch : make(chan int)go func() {ch - 1}()res : -chfmt.Println(res)
}1很简单对吗我们做了一个名为ch的通道。我们有一个goroutine向ch发送1我们接收该数据并将其保存到res。
你问为什么我们在这里需要一个goroutine因为不这样做会导致死锁。
func main() {unbufferedChFail()
}func unbufferedChFail() {ch : make(chan int)ch - 1res : -chfmt.Println(res)
}fatal error: all goroutines are asleep - deadlock!们碰到了一个新词。什么是死锁死锁就是你的程序被卡住了。为什么上面的代码会卡在死锁中
为了理解这一点我们需要知道通道的一个重要特性。我们创建了一个无缓冲的通道这意味着在某一特定时间内没有任何东西可以被存储在其中。这意味着发送方和接收方都必须同时准备好才能在通道上传输数据。
在失败的例子中发送和接收的动作依次发生。我们发送1到ch但在那个时候没有人接收数据。接收发生在稍后的一行这意味着在接收行运行之前1不能被发送。可悲的是1不能先被发送因为ch是没有缓冲的没有空间来容纳任何数据。
在这个工作例子中发送和接收的动作同时发生。主函数启动了goroutine并试图从ch中接收此时goroutine正在向ch发送1。
另一种从通道接收而不发生死锁的方法是先关闭通道。
func main() {unbufferedCh()
}func unbufferedCh() {ch2 : make(chan int)close(ch2)res2 : -ch2fmt.Println(res2)
}0关闭通道意味着不能再向它发送数据。我们仍然可以从该通道中接收它。对于未缓冲的通道从一个关闭的通道接收将返回一个通道类型的零值。 总结一下我们学到了这些东西
通道是goroutines之间相互交流的方式。你可以通过通道发送和接收数据。通道是强类型的。没有缓冲的通道没有空间来存储数据所以发送和接收必须同时进行。否则你的代码就会陷入死锁。一个封闭的通道将不接受任何数据。从一个封闭的非缓冲通道接收数据将返回一个零值。
如果通道能保持数据一段时间那不是很好吗这里就是缓冲通道发挥作用的地方。
Buffered channels, the portal that is somehow cylindrical?
缓冲通道是带有缓冲器的通道。数据可以存储在其中所以发送和接收不需要同时进行。
func main() {bufferedCh()
}func bufferedCh() {ch : make(chan int, 1)ch - 1res : -chfmt.Println(res)
}1在这里1被储存在ch里面直到我们收到它。
很明显我们不能向一个满了缓冲区的通道发送更多的信息。你需要在缓冲区内有空间才能发送更多。
func main() {bufferedChFail()
}func bufferedChFail() {ch : make(chan int, 1)ch - 1ch - 2res : -chfmt.Println(res)
}fatal error: all goroutines are asleep - deadlock!你也不能从一个空的缓冲通道接收。
func main() {bufferedChFail2()
}func bufferedChFail2() {ch : make(chan int, 1)ch - 1res : -chres2 : -chfmt.Println(res, res2)
}fatal error: all goroutines are asleep - deadlock!如果一个通道已满发送操作将等待直到有可用的空间。这在这段代码中得到了证明。
func main() {bufferedCh2()
}func bufferedCh2() {ch : make(chan int, 1)ch - 1go func() {ch - 2}()res : -chfmt.Println(res)
}1我们接收一次是为了取出1这样goroutine就可以发送2到通道。我们没有从ch接收两次所以只接收1。
我们也可以从封闭的缓冲通道接收。在这种情况下我们可以在封闭的通道上设置范围来迭代里面的剩余项目。
func main() {bufferedChRange()
}func bufferedChRange() {ch : make(chan int, 3)ch - 1ch - 2ch - 3close(ch)for res : range ch {fmt.Println(res)}// you could also do this// fmt.Println(-ch)// fmt.Println(-ch)// fmt.Println(-ch)
}1
2
3在一个开放的通道上测距将永远不会停止。这意味着在某些时候通道将是空的测距循环将试图从一个空的通道接收从而导致死锁。 总结一下
缓冲通道是有空间容纳项目的通道。发送和接收不一定要同时进行与非缓冲通道不同。向一个满的通道发送和从一个空的通道接收将导致一个死锁。你可以在一个封闭的通道上进行迭代以接收缓冲区内的剩余值。
等待戈多…我的意思是goroutines来完成使用通道
通道可以用来同步goroutines。还记得我告诉过你在通过无缓冲通道传输数据之前发送方和接收方必须都准备好了吗这意味着接收方将等待直到发送方准备好。我们可以说接收是阻断的意思是接收方将阻断其他代码的运行直到它收到东西。让我们用这个巧妙的技巧来同步我们的goroutines。
func main() {basicSyncing()
}func basicSyncing() {done : make(chan struct{})go func() {for i : 0; i 5; i {fmt.Printf(%s worker %d start\n, fmt.Sprint(time.Now()), i)time.Sleep(time.Duration(rand.Intn(5)) * time.Second)}close(done)}()-donefmt.Println(exiting...)
}
我们做了一个done通道负责阻断代码直到goroutine完成。done可以是任何类型但struct{}经常被用于这些类型的通道。它的目的不是为了传输结构所以它的类型并不重要。 一旦工作完成worker goroutine 将关闭 done。此时我们可以从 done 中接收它将是一个空结构。接收动作解除了代码的阻塞使其可以退出。 这就是我们使用通道等待goroutine完成的方式。
总结
并发可能看起来是一个令人生畏的话题。我当然认为是这样的。然而在了解了基础知识之后我认为实现起来真的很美。希望你们能从这个教程中有所收获我们仅仅是触及了表面Go为我们提供的东西还有很多。下一次我们将在更多的并发性教程中见面。再见!
