Concurrency Go编程语言交互并发执行

我有两个并发的go例程，如下所示

Routine 1{                                                  

routine procedure   

critical section{                                                     
}

routine procedure                        
} 

Routine 2{                                                  

routine procedure   

critical section{                                                     
}

routine procedure                       
} 

---

是否可以使用一些go内置函数来实现关键部分？

您可以尝试使用缓冲通道：

c := make(chan int, 2)

---

这将在实际发送数据之前对发送的数据进行缓冲。

您的意思是这样的吗

package main

import "fmt"

func ping(recv <-chan int, send chan<- int, end chan<- bool) {
    fmt.Println("ping")
    send <- 11
    send <- 12
    r1 := <-recv
    r2 := <-recv
    fmt.Println("ping", r1, r2)
    end <- true
}

func pong(recv <-chan int, send chan<- int, end chan<- bool) {
    fmt.Println("pong")
    r1 := <-recv
    r2 := <-recv
    send <- 21
    send <- 22
    fmt.Println("pong", r1, r2)
    end <- true
}

func main() {
    chEnd := make(chan bool)
    chPing := make(chan int, 2)
    chPong := make(chan int, 2)
    go ping(chPing, chPong, chEnd)
    go pong(chPong, chPing, chEnd)
    <-chEnd
    <-chEnd
    fmt.Println("end")
}

---

我不认为，在go中有任何库来实现关键部分。我认为ARPSSS需要一个库。

有几种方法是可能的。一个简单的方法是使用为完整“事件”键入的通道

主程序包
类型int2结构{
a、 b int
}
职能路线1（德克萨斯州、德克萨斯州和佛罗里达州）{
变量x，y int
// ...
tx您的问题：

我有N个并发的go例程（或多或少都是为了相同的目的）。每个例程都有一个临界区。在进入临界区之前，每个例程只需执行一些消息发送任务。当它进入临界区时，我需要所有其他例程必须停止执行，直到它退出临界区。是否可以使用GO中的任何库函数

你在问什么（当一个goroutine处于关键部分时，强制停止所有其他goroutine）不是Go程序中的典型情况。没有库函数来停止所有其他goroutine，因此您需要通过在程序中的goroutine之间设计适当的同步来停止它们。典型情况是所有goroutine（可能）同时运行，但以某种方式被阻止的goroutine除外

要控制对Go程序中共享资源的并发访问，您可以使用Go通道、
“sync”
包、管道或网络连接

使用
sync.Mutex
，Go代码可能如下所示（但请记住，只要可能，Go程序最好使用Go通道而不是互斥）：

这是一个与Atom解决方案等效的基于通道的解决方案。请在开始Goroutine之前执行此操作：

doingFileModificationJobs := make(chan bool, 1)
doingFileModificationJobs <- false

与

我已经在使用const bufsize=10 c:=make（chan int，bufsize）。但是，我想锁定例程2，直到例程1发送完成。尝试查看标准库中的同步包。实际上我有N个例程，每个例程都有一个关键部分（为了简化，我使用发送方法）现在，有可能在围棋中实现关键部分吗？若你们有N个例程，那个么routineM是什么呢，其中1我有N个并发围棋例程（都或多或少有相同的目的）。每个都有一个临界区。在进入临界区之前，每个例程只做一些消息发送工作。当它进入临界区时，我需要所有其他例程必须停止执行，直到它退出临界区。是否可以使用GO中的任何库函数？实际上，在临界区中，每个进程都会进行一些文件修改jnml，你说得很对。但是，实际上我的问题是错的。我修改它是为了让它更清楚。
package main

type int2 struct {
        a, b int
}

func Routine1(tx, rx chan int2) {
        var x, y int
        // ...
        tx <- int2{x, y}
        // ...
        z := <- rx // Two rx values in z.a, z.b
        // ...
}

func Routine2(rx, tx chan int2) {
        var x, y int
        // ...
        z := <- rx // Two rx values in z.a, z.b
        // ...
        tx <- int2{x, y}
        // ...
}

func main() {
        // ...
        tx, rx := make(chan int2), make(chan int2)
        go Routine1(tx, rx)
        go Routine2(rx, tx)
        // ...
}

package main

import "sync"

var m sync.Mutex
var wg sync.WaitGroup

func routine1() {
    ... do something ...

    m.Lock()
    ... critical section (access the shared resource here) ...
    m.Unlock()

    ... do something ...
    wg.Done()
}

func routine2() {
    ... do something ...

    m.Lock()
    ... critical section (access the shared resource here) ...
    m.Unlock()

    ... do something ...
    wg.Done()
}

func main() {
    wg.Add(1); go routine1()
    wg.Add(1); go routine2()
    wg.Wait()
}

doingFileModificationJobs := make(chan bool, 1)
doingFileModificationJobs <- false

critical section{

<-doingFileModicationJobs

doingFileModications <- false