goroutines 和结构化并发是 go 编程中的游戏规则改变者。它们提供了管理并发操作的强大方法，使我们的代码更加高效和健壮。让我们探索 nursery 模式，这是一种为并发编程的混乱带来秩序的技术。
nursery 模式就是创建有组织的任务组。它使我们能够更好地控制 goroutine 的行为方式，并帮助我们更优雅地处理错误。将其视为保持并发代码整洁且易于管理的一种方法。
为了实现 nursery 模式，我们首先创建一个父上下文来监督一组子 goroutine。如果出现问题，此父上下文可以取消其所有子上下文，确保我们不会留下任何挂起的线程。
这是我们如何实现一个简单托儿所的基本示例：
type nursery struct {
wg sync.waitgroup
ctx context.context
cancel context.cancelfunc
}
func newnursery() (*nursery, context.context) {
ctx, cancel := context.withcancel(context.background())
return &nursery{
ctx: ctx,
cancel: cancel,
}, ctx
}
func (n *nursery) go(f func() error) {
n.wg.add(1)
go func() {
defer n.wg.done()
if err := f(); err != nil {
n.cancel()
}
}()
}
func (n *nursery) wait() {
n.wg.wait()
}
这个托儿所允许我们生成多个 goroutine 并等待它们全部完成。如果其中任何一个返回错误，托儿所就会取消所有其他 goroutine。
nursery 模式的主要优点之一是它如何处理恐慌。在 go 中，一个 goroutine 中的恐慌不会自动停止其他 goroutines。这可能会导致资源泄漏和状态不一致。有了托儿所，我们可以捕捉恐慌并确保所有相关的 goroutine 都正确关闭。
让我们加强我们的托儿所以应对恐慌：
func (n *nursery) go(f func() error) {
n.wg.add(1)
go func() {
defer n.wg.done()
defer func() {
if r := recover(); r != nil {
fmt.println("recovered from panic:", r)
n.cancel()
}
}()
if err := f(); err != nil {
n.cancel()
}
}()
}
现在，如果有任何 goroutine 发生恐慌，我们将捕获它，记录它，并取消托儿所中的所有其他 goroutine。
nursery 模式的另一个重要方面是资源管理。在分布式系统中，我们经常需要协调使用共享资源的多个操作。托儿所可以帮助确保这些资源得到正确的获取和释放。
这是我们如何使用托儿所来管理数据库连接的示例：
func main() {
nursery, ctx := newnursery()
defer nursery.wait()
dbpool := createdbpool(ctx)
defer dbpool.close()
nursery.go(func() error {
return processorders(ctx, dbpool)
})
nursery.go(func() error {
return updateinventory(ctx, dbpool)
})
nursery.go(func() error {
return sendnotifications(ctx, dbpool)
})
}
在此示例中，我们创建一个数据库连接池并将其传递给多个并发操作。 nursery 确保如果任何操作失败，所有其他操作都会被取消，并且数据库池会正确关闭。
当我们需要限制并发时，nursery 模式确实非常有用。在许多现实场景中，我们希望同时运行多个操作，但不是一次全部运行。我们可以修改我们的 nursery 以包含一个限制并发操作数量的信号量：
type nursery struct {
wg sync.waitgroup
ctx context.context
cancel context.cancelfunc
semaphore chan struct{}
}
func newnursery(maxconcurrency int) (*nursery, context.context) {
ctx, cancel := context.withcancel(context.background())
return &nursery{
ctx: ctx,
cancel: cancel,
semaphore: make(chan struct{}, maxconcurrency),
}, ctx
}
func (n *nursery) go(f func() error) {
n.wg.add(1)
go func() {
n.semaphore <- struct{}{}
defer func() {
<-n.semaphore
n.wg.done()
}()
if err := f(); err != nil {
n.cancel()
}
}()
}
此实现确保不超过 maxconcurrency goroutine 同时运行，防止资源耗尽。
超时是并发编程的另一个关键方面，尤其是在分布式系统中。我们可以轻松地向我们的托儿所添加超时功能：
func (n *nursery) gowithtimeout(f func() error, timeout time.duration) {
n.wg.add(1)
go func() {
defer n.wg.done()
timeoutctx, cancel := context.withtimeout(n.ctx, timeout)
defer cancel()
done := make(chan error, 1)
go func() {
done <- f()
}()
select {
case err := <-done:
if err != nil {
n.cancel()
}
case <-timeoutctx.done():
fmt.println("operation timed out")
n.cancel()
}
}()
}
该方法允许我们为每个操作设置超时时间。如果操作未在指定时间内完成，则会被取消，并且 nursery 中的所有其他操作也会被取消。
在处理 goroutine 之间的复杂依赖关系时，nursery 模式变得特别强大。在许多现实场景中，某些操作取决于其他操作的结果。我们可以扩展我们的托儿所来处理这些依赖关系：
type task struct {
f func() error
deps []*task
}
func (n *nursery) addtask(t *task) {
n.wg.add(1)
go func() {
defer n.wg.done()
for _, dep := range t.deps {
if err := dep.f(); err != nil {
n.cancel()
return
}
}
if err := t.f(); err != nil {
n.cancel()
}
}()
}
这使我们能够定义具有依赖关系的任务，确保它们以正确的顺序运行，同时仍然尽可能从并发中受益。
nursery 模式不仅仅是管理 goroutine；它还涉及管理 goroutine。它是关于创建更可维护和更健壮的并发代码。通过提供一种结构化的方式来管理并发，它可以帮助我们避免常见的陷阱，例如 goroutine 泄漏和竞争条件。
在微服务和大规模应用程序中，nursery 模式可以改变游戏规则。它使我们能够将复杂的工作流程分解为可管理、可取消的单元。这在处理分布式事务或跨多个服务的复杂业务流程时特别有用。
这是我们如何在微服务架构中使用 nursery 模式的示例：
func processorder(orderid string) error {
nursery, ctx := newnursery(5) // allow up to 5 concurrent operations
defer nursery.wait()
var inventoryupdated, paymentprocessed, ordershipped bool
nursery.go(func() error {
return updateinventory(ctx, orderid)
})
nursery.go(func() error {
return processpayment(ctx, orderid)
})
nursery.gowithtimeout(func() error {
return shiporder(ctx, orderid)
}, 30*time.second)
nursery.go(func() error {
for {
select {
case <-ctx.done():
return ctx.err()
default:
if inventoryupdated && paymentprocessed && ordershipped {
return sendconfirmationemail(orderid)
}
time.sleep(100 * time.millisecond)
}
}
})
return nil
}
在此示例中，我们使用多个并发操作来处理订单。我们同时更新库存、处理付款和发货订单。我们还有一个 goroutine 等待所有这些操作完成后再发送确认电子邮件。如果任何操作失败或超时，所有其他操作都将被取消。
nursery 模式在并发代码中的错误处理方面也很出色。当处理多个 goroutine 时，传统的错误处理可能会变得复杂。 nursery 提供了一种集中的方式来管理错误：
type NurseryError struct {
Errors []error
}
func (ne *NurseryError) Error() string {
var errStrings []string
for _, err := range ne.Errors {
errStrings = append(errStrings, err.Error())
}
return strings.Join(errStrings, "; ")
}
func (n *Nursery) Go(f func() error) {
n.wg.Add(1)
go func() {
defer n.wg.Done()
if err := f(); err != nil {
n.errMu.Lock()
n.errors = append(n.errors, err)
n.errMu.Unlock()
n.cancel()
}
}()
}
func (n *Nursery) Wait() error {
n.wg.Wait()
if len(n.errors) > 0 {
return &NurseryError{Errors: n.errors}
}
return nil
}
此实现收集了 nursery 的 goroutine 中发生的所有错误。当我们调用 wait() 时，它会返回一个错误，其中封装了所有单独的错误。
nursery 模式不仅仅是管理 goroutine；它还涉及管理 goroutine。这是关于创建更具弹性的系统。通过提供结构化的方式来处理并发，它可以帮助我们构建能够优雅地处理故障和意外情况的应用程序。
总之，nursery 模式是 go 中管理并发的强大工具。它提供了一种结构化方法来生成和管理 goroutine、处理错误和恐慌以及协调复杂的工作流程。通过实现这种模式，我们可以创建更健壮、可维护和高效的并发代码，特别是在大规模应用程序和微服务架构中。随着我们继续构建更复杂的分布式系统，这样的模式在我们的 go 编程工具包中将变得越来越重要。
我们的创作
一定要看看我们的创作：
投资者中心 | 智能生活 | 时代与回响 | 令人费解的谜团 | 印度教 | 精英开发 | js学校
我们在媒体上
科技考拉洞察 | 时代与回响世界 | 投资者中央媒体 | 令人费解的谜团 | 科学与时代媒介 | 现代印度教
