go的反义词wait可以吗

不可以。

创新互联建站主要从事成都网站设计、网站制作、网页设计、企业做网站、公司建网站等业务。立足成都服务武清,十余年网站建设经验,价格优惠、服务专业,欢迎来电咨询建站服务:13518219792

wait是等待的意思，go是去的意思。

go反义词：come（来）、back（返回）

希望我的回答对你有帮助，满意请采纳，谢谢。

Go语言设计与实现（上）

基本设计思路：

类型转换、类型断言、动态派发。iface，eface。

反射对象具有的方法：

编译优化：

内部实现：

实现 Context 接口有以下几个类型（空实现就忽略了）：

互斥锁的控制逻辑：

设计思路：

（以上为写被读阻塞，下面是读被写阻塞）

总结，读写锁的设计还是非常巧妙的：

设计思路：

WaitGroup 有三个暴露的函数:

部件：

设计思路：

结构：

Once 只暴露了一个方法：

实现：

三个关键点：

细节：

让多协程任务的开始执行时间可控（按顺序或归一）。（Context 是控制结束时间）

设计思路： 通过一个锁和内置的 notifyList 队列实现，Wait() 会生成票据，并将等待协程信息加入链表中，等待控制协程中发送信号通知一个（Signal()）或所有（Boardcast()）等待者（内部实现是通过票据通知的）来控制协程解除阻塞。

暴露四个函数：

实现细节：

部件：

包： golang.org/x/sync/errgroup

作用：开启 func() error 函数签名的协程，在同 Group 下协程并发执行过程并收集首次 err 错误。通过 Context 的传入，还可以控制在首次 err 出现时就终止组内各协程。

设计思路：

结构：

暴露的方法：

实现细节：

注意问题：

包： "golang.org/x/sync/semaphore"

作用：排队借资源（如钱，有借有还）的一种场景。此包相当于对底层信号量的一种暴露。

设计思路：有一定数量的资源 Weight，每一个 waiter 携带一个 channel 和要借的数量 n。通过队列排队执行借贷。

结构：

暴露方法：

细节：

部件：

细节：

包： "golang.org/x/sync/singleflight"

作用：防击穿。瞬时的相同请求只调用一次，response 被所有相同请求共享。

设计思路：按请求的 key 分组（一个 *call 是一个组，用 map 映射存储组），每个组只进行一次访问，组内每个协程会获得对应结果的一个拷贝。

结构：

逻辑：

细节：

部件：

如有错误，请批评指正。

golang 进程创建，fork，以及热重启（无缝升级）

一般来说，进程的操作使用的是一些系统的命令，所以go内部使用os包，进行一些运行系统命令的操作

os 包及其子包 os/exec 提供了创建进程的方法。

一般的，应该优先使用 os/exec 包。因为 os/exec 包依赖 os 包中关键创建进程的 API，为了便于理解，我们先探讨 os 包中和进程相关的部分。

Unix :fork创建一个进程，（及其一些变种，如 vfork、clone）。

Go:Linux 下创建进程使用的系统调用是 clone。

允许一进程（父进程）创建一新进程（子进程）。具体做法是，新的子进程几近于对父进程的翻版：子进程获得父进程的栈、数据段、堆和执行文本段的拷贝。可将此视为把父进程一分为二。

终止一进程，将进程占用的所有资源（内存、文件描述符等）归还内核，交其进行再次分配。参数 status 为一整型变量，表示进程的退出状态。父进程可使用系统调用 wait() 来获取该状态。

目的有二：其一，如果子进程尚未调用 exit() 终止，那么 wait 会挂起父进程直至子进程终止；其二，子进程的终止状态通过 wait 的 status 参数返回。

加载一个新程序（路径名为 pathname，参数列表为 argv，环境变量列表为 envp）到当前进程的内存。这将丢弃现存的程序文本段，并为新程序重新创建栈、数据段以及堆。通常将这一动作称为执行一个新程序。

没有直接提供 fork 系统调用的封装，而是将 fork 和 execve 合二为一，提供了 syscall.ForkExec。如果想只调用 fork，得自己通过 syscall.Syscall(syscall.SYS_FORK, 0, 0, 0) 实现。

os.Process 存储了通过 StartProcess 创建的进程的相关信息。

一般通过 StartProcess 创建 Process 的实例，函数声明如下：

它使用提供的程序名、命令行参数、属性开始一个新进程。StartProcess 是一个低级别的接口。os/exec 包提供了高级别的接口，一般应该尽量使用 os/exec 包。如果出错，错误的类型会是 *PathError。

属性定义如下：

FindProcess 可以通过 pid 查找一个运行中的进程。该函数返回的 Process 对象可以用于获取关于底层操作系统进程的信息。在 Unix 系统中，此函数总是成功，即使 pid 对应的进程不存在。

Process 提供了四个方法：Kill、Signal、Wait 和 Release。其中 Kill 和 Signal 跟信号相关，而 Kill 实际上就是调用 Signal，发送了 SIGKILL 信号，强制进程退出，关于信号，后续章节会专门讲解。

Release 方法用于释放 Process 对象相关的资源，以便将来可以被再使用。该方法只有在确定没有调用 Wait 时才需要调用。Unix 中，该方法的内部实现只是将 Process 的 pid 置为 -1。

通过 os 包可以做到运行外部命令，如前面的例子。不过，Go 标准库为我们封装了更好用的包： os/exec，运行外部命令，应该优先使用它，它包装了 os.StartProcess 函数以便更容易的重定向标准输入和输出，使用管道连接 I/O，以及作其它的一些调整。

exec.LookPath 函数在 PATH 指定目录中搜索可执行程序，如 file 中有 /，则只在当前目录搜索。该函数返回完整路径或相对于当前路径的一个相对路径。

func LookPath(file string) (string, error)

如果在 PATH 中没有找到可执行文件，则返回 exec.ErrNotFound。

Cmd 结构代表一个正在准备或者在执行中的外部命令，调用了 Run、Output 或 CombinedOutput 后，Cmd 实例不能被重用。

一般的，应该通过 exec.Command 函数产生 Cmd 实例：

用法

得到 * Cmd 实例后，接下来一般有两种写法：

前面讲到，通过 Cmd 实例后，有两种方式运行命令。有时候，我们不只是简单的运行命令，还希望能控制命令的输入和输出。通过上面的 API 介绍，控制输入输出有几种方法：

参考资料：

golang多线程简单逻辑

实现指定个核心最大化使用，比如核心总数减一。

必要的库。

要使用的cpu数量，建议不全使用。

建立管道。

声明使用的cpu数。

建立互斥关系，本例中主要为了实现所有线程执行完后再执行后续程序。

创建cpu数减1个线程

后面每个任务结束时要done一个wg，这里根据具体情况加，是循环就在每个循环里加，保证后面能全部done即可

没有缓冲的、阻塞式的往管道传递字符串。

Wait是等所有线程都执行完，即增加的数字被全done掉。

关闭管道。

假设已有的函数是ReadLogs，在它的基础上加个Wg加函数名的新函数，我觉得这种方式不改变原有的，比较舒服。

大意是：循环从管道读取字符串，读不到了就跳出循环。

每个ReadLogs()之后加一个wg.Done()，相当于计数减一。

ReadLogs()就是要执行的任务，不再解释。

就是开指定个线程。

管道阻塞传值。

wg同步。

WgReadLogs循环接收。

如何优雅地等待所有的goroutine退出

goroutine和channel是Go语言非常棒的特色，它们提供了一种非常轻便易用的并发能力。但是当您的应用进程中有很多goroutine的时候，如何在主流程中等待所有的goroutine 退出呢？

1 通过Channel传递退出信号

Go的一大设计哲学就是：通过Channel共享数据，而不是通过共享内存共享数据。主流程可以通过channel向任何goroutine发送停止信号，就像下面这样：

func run(done chan int) {

for {

select {

case -done:

fmt.Println("exiting...")

done - 1

break

default:

}

time.Sleep(time.Second * 1)

fmt.Println("do something")

}

}

func main() {

c := make(chan int)

go run(c)

fmt.Println("wait")

time.Sleep(time.Second * 5)

c - 1

-c

fmt.Println("main exited")

}

这种方式可以实现优雅地停止goroutine，但是当goroutine特别多的时候，这种方式不管在代码美观上还是管理上都显得笨拙不堪。

2 使用waitgroup

sync包中的Waitgroup结构，是Go语言为我们提供的多个goroutine之间同步的好刀。下面是官方文档对它的描述：

A WaitGroup waits for a collection of goroutines to finish. The main goroutine calls Add to set the number of goroutines to wait for.

Then each of the goroutines runs and calls Done when finished. At the same time, Wait can be used to block until all goroutines have finished.

通常情况下，我们像下面这样使用waitgroup:

创建一个Waitgroup的实例，假设此处我们叫它wg

在每个goroutine启动的时候，调用wg.Add(1)，这个操作可以在goroutine启动之前调用，也可以在goroutine里面调用。当然，也可以在创建n个goroutine前调用wg.Add(n)

当每个goroutine完成任务后，调用wg.Done()

在等待所有goroutine的地方调用wg.Wait()，它在所有执行了wg.Add(1)的goroutine都调用完wg.Done()前阻塞，当所有goroutine都调用完wg.Done()之后它会返回。

那么，如果我们的goroutine是一匹不知疲倦的牛，一直孜孜不倦地工作的话，如何在主流程中告知并等待它退出呢？像下面这样做：

type Service struct {

// Other things

ch chan bool

waitGroup *sync.WaitGroup

}

func NewService() *Service {

s := Service{

// Init Other things

ch: make(chan bool),

waitGroup: sync.WaitGroup{},

}

return s

}

func (s *Service) Stop() {

close(s.ch)

s.waitGroup.Wait()

}

func (s *Service) Serve() {

s.waitGroup.Add(1)

defer s.waitGroup.Done()

for {

select {

case -s.ch:

fmt.Println("stopping...")

return

default:

}

s.waitGroup.Add(1)

go s.anotherServer()

}

}

func (s *Service) anotherServer() {

defer s.waitGroup.Done()

for {

select {

case -s.ch:

fmt.Println("stopping...")

return

default:

}

// Do something

}

}

func main() {

service := NewService()

go service.Serve()

// Handle SIGINT and SIGTERM.

ch := make(chan os.Signal)

signal.Notify(ch, syscall.SIGINT, syscall.SIGTERM)

fmt.Println(-ch)

// Stop the service gracefully.

service.Stop()

}

Go 语言 channel 的阻塞问题

Hello，大家好，又见面了！上一遍我们将 channel 相关基础以及使用场景。这一篇，还需要再次进阶理解channel 阻塞问题。以下创建一个chan类型为int，cap 为3。

channel 内部其实是一个环形buf数据结构 ，是一种滑动窗口机制，当make完后，就分配在 Heap 上。

上面，向 chan 发送一条“hello”数据：

如果 G1 发送数据超过指定cap时，会出现什么情况？

看下面实例：

以上会出现什么，chan 缓冲区允许大小为1，如果再往chan仍数据，满了就会被阻塞，那么是如何实现阻塞的呢？当 chan 满时，会进入 gopark，此时 G1 进入一个 waiting 状态，然后会创建一个 sudog 对象，其实就sendq队列，把 200放进去。等 buf 不满的时候，再唤醒放入buf里面。

通过如下源码，你会更加清晰：

上面，从 chan 获取数据：

Go 语言核心思想：“Do not communicate by sharing memory; instead, share memory by communicating.” 你可以看看这本书名叫：Effective Go

如果接收者，接收一个空对象，也会发生什么情况？

代码示例 ：

也会报错如下：

上面，从 chan 取出数据，可是没有数据了。此时，它会把 接收者 G2 阻塞掉，也是和G1发送者一样，也会执行 gopark 将状态改为 waiting，不一样的点就是。

正常情况下，接收者G2作为取出数据是去 buf 读取数据的，但现在，buf 为空了，此时，接收者G2会将sudog导出来，因为现在G2已经被阻塞了嘛，会把G2给G，然后将 t := -ch 中变量 t 是在栈上的地址，放进去 elem ，也就是说，只存它的地址指针在sudog里面。

最后， ch - 200 当G1往 chan 添加200这个数据，正常情况是将数据添加到buf里面，然后唤醒 G2 是吧，而现在是将 G1 的添加200数据直接干到刚才G2阻塞的t这里变量里面。

你会认为，这样真的可以吗？想一想，G2 本来就是已经阻塞了，然后我们直接这么干肯定没有什么毛病，而且效率提高了，不需要再次放入buf再取出，这个过程也是需要时间。不然，不得往chan添加数据需要加锁、拷贝、解锁一序列操作，那肯定就慢了，我想Go语言是为了高效及内存使用率的考虑这样设计的。（注意，一般都是在runtime里面完成，不然会出现象安全问题。）

总结 ：

chan 类型的特点：chan 如果为空，receiver 接收数据的时候就会阻塞等待，直到 chan 被关闭或者有新的数据到来。有这种个机制，就可以实现 wait/notify 的设计模式。

相关面试题：