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学校
我们在媒体上
科技考拉洞察 | 时代与回响世界 | 投资者中央媒体 | 令人费解的谜团 | 科学与时代媒介 | 现代印度教
