@colin4k1024/tsp 2.4.0

package/skills/goframe-v2/references//347/273/204/344/273/266/345/210/227/350/241/250//347/263/273/347/273/237/347/233/270/345/205/263//346/227/266/351/227/264/347/256/241/347/220/206-gtime//346/227/266/351/227/264/347/256/241/347/220/206-/346/227/266/345/214/272/350/256/276/347/275/256.md

@@ -0,0 +1,106 @@
+## `SetTimeZone` 设置全局时区
+
+```go
+package main
+
+import (
+    "fmt"
+    "time"
+
+    "github.com/gogf/gf/v2/os/gtime"
+)
+
+func main() {
+    // 设置进程全局时区
+    err := gtime.SetTimeZone("Asia/Tokyo")
+    if err != nil {
+        panic(err)
+    }
+
+    // 使用gtime获取当前时间
+    fmt.Println(gtime.Now().String())
+
+    // 使用标准库获取当前时间
+    fmt.Println(time.Now().String())
+}
+```
+
+执行后，输出结果为：
+
+```html
+2023-01-06 15:27:38
+2023-01-06 15:27:38.753909 +0900 JST m=+0.002758145
+```
+
+## 时区设置注意事项
+
+### `SetTimeZone` 方法多次调用报错
+
+`SetTimeZone` 方法只允许全局设置一次时区，如果多次调用，并且设置的时区不一样，后续调用将会失败，并返回 `error`。
+
+### 业务项目中， `time` 包初始化问题
+
+程序时区的全局设置必须要在标准库的 `time` 包 `import` 之前调用，因为标准库的 `time` 包在 `import` 时会执行初始化，之后无法再全局修改程序时区，只能通过 `ToLocation` 方法（或者标准库 `In` 方法）对特定时间对象执行时区转换。对时间对象使用 `ToLocation` 转换的例子：
+
+```go
+package main
+
+import (
+    "fmt"
+    "time"
+
+    "github.com/gogf/gf/v2/os/gtime"
+)
+
+func main() {
+    // 设置进程全局时区
+    err := gtime.SetTimeZone("Asia/Tokyo")
+    if err != nil {
+        panic(err)
+    }
+
+    // 使用gtime获取当前时间
+    fmt.Println(gtime.Now())
+
+    // 使用标准库获取当前时间
+    fmt.Println(time.Now())
+
+    // 对特定时间对象执行时区转换
+    local, err := time.LoadLocation("Asia/Shanghai")
+    if err != nil {
+        panic(err)
+    }
+    fmt.Println(gtime.Now().ToLocation(local))
+}
+```
+
+执行后，终端输出：
+
+```html
+2023-01-06 15:37:38
+2023-01-06 15:37:38.753909 +0900 JST m=+0.002758145
+2023-01-06 14:37:38
+```
+
+在业务项目中，往往在 `main` 包之前会有很多业务的包 `import`，会引起 `time` 包的初始化问题。因此，如果需要全局设置时区，建议通过一个独立的包来调用 `SetTimeZone` 方法，并且在 `main` 包的最开头执行 `import` 规避 `time` 包初始化的问题。例如：
+
+相关参考链接： [https://stackoverflow.com/questions/54363451/setting-timezone-globally-in-golang](https://stackoverflow.com/questions/54363451/setting-timezone-globally-in-golang)
+
+```go
+package main
+
+import (
+    _ "boot/time"
+
+    "fmt"
+    "time"
+)
+
+func main() {
+    // 使用gtime获取当前时间
+    fmt.Println(gtime.Now().String())
+
+    // 使用标准库获取当前时间
+    fmt.Println(time.Now().String())
+}
+```

package/skills/goframe-v2/references//347/273/204/344/273/266/345/210/227/350/241/250//347/263/273/347/273/237/347/233/270/345/205/263//346/227/266/351/227/264/347/256/241/347/220/206-gtime//346/227/266/351/227/264/347/256/241/347/220/206-/346/227/266/351/227/264/345/257/271/350/261/241.md

@@ -0,0 +1,157 @@
+## 时间对象
+
+创建 `gtime.Time` 对象可以通过标准库 `time.Time` 对象、Unix时间戳、时间字符串（如： `2018-07-18 12:01:00`）、自定义时间字符串（需要给定格式，支持自定义格式及标准库格式）。
+
+## 创建对象
+
+可以通过 `gtime.New` 方法创建 `gtime.Time` 对象，该方法支持 `time.Time`、时间戳、时间字符串创建对象。其中时间戳支持到纳秒的时间整型长度。 例如：
+
+```go
+// 通过时间字符串创建
+gtime.New("2020-10-24 12:00:00")
+// 通过time.Time对象创建
+gtime.New(time.Now())
+// 通过时间戳(秒)创建
+gtime.New(1603710586)
+// 通过时间戳(纳秒)创建
+gtime.New(1603710586660409000)
+```
+
+此外，时间字符串支持常见时间类型，例如：
+
+```html
+2017-12-14 04:51:34 +0805 LMT
+2017-12-14 04:51:34 +0805 LMT
+2006-01-02T15:04:05Z07:00
+2014-01-17T01:19:15+08:00
+2018-02-09T20:46:17.897Z
+2018-02-09 20:46:17.897
+2018-02-09T20:46:17Z
+2018-02-09 20:46:17
+2018/10/31 - 16:38:46
+2018-02-09
+2018.02.09
+
+01-Nov-2018 11:50:28
+01/Nov/2018 11:50:28
+01.Nov.2018 11:50:28
+01.Nov.2018:11:50:28
+日期连接符号支持'-'、'/'、'.'
+```
+
+## 使用示例
+
+### 示例1，自定义格式化语法
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/gogf/gf/v2/os/gtime"
+)
+
+func main() {
+    formats := []string{
+        "Y-m-d H:i:s.u",
+        "D M d H:i:s T O Y",
+        "\\T\\i\\m\\e \\i\\s: h:i:s a",
+        "2006-01-02T15:04:05.000000000Z07:00",
+    }
+    t := gtime.Now()
+    for _, f := range formats {
+        fmt.Println(t.Format(f))
+    }
+}
+```
+
+在该示例中，我们给定了四种 `format` 格式，并将当前时间用这四种格式转换后打印出来。执行后，输出结果如下：
+
+```html
+2018-07-22 11:17:13.797
+Sun Jul 22 11:17:13 CST +0800 2018
+Time is: 11:17:13 am
+2006-01-02CST15:04:05.000000000Z07:00
+```
+
+可以看到，这个示例演示了几个需要注意的地方：
+
+1. 如果使用的字母与格式化字符冲突时，可以使用 `\` 符号转义该字符，这样时间格式解析器会认为该字符不是格式化字符，而是普通字母。因此这里的第三个字符串示例输出为： `Time is: 11:17:13 am`
+2. 使用 `Format` 方法接收的是自定义的时间格式化语法（如： `Y-m-d H:i:s`），而非标准库的时间格式语法（如： `2006-01-02 15:04:05`），因此在这里的第四个字符串示例中原样输出参数值；
+
+### 示例2，标准库格式化语法
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/gogf/gf/v2/os/gtime"
+)
+
+func main() {
+    formats := []string{
+        "2006-01-02 15:04:05.000",
+        "Mon Jan _2 15:04:05 MST 2006",
+        "Time is: 03:04:05 PM",
+        "2006-01-02T15:04:05.000000000Z07:00 MST",
+    }
+    t := gtime.Now()
+    for _, f := range formats {
+        fmt.Println(t.Layout(f))
+    }
+}
+```
+
+在该示例中，我们使用四种标准库的时间格式化语法格式化当前的时间并输出结果到终端。执行后，输出结果为：
+
+```html
+2018-07-22 11:28:13.945
+Sun Jul 22 11:28:13 CST 2018
+Time is: 11:28:13 AM
+2018-07-22T11:28:13.945153275+08:00 CST
+```
+
+有几个需要说明的地方：
+
+1. 自定义时间格式化语法与标准库时间格式化语法并不冲突，前者使用 `Format` 方法，后者使用 `Layout` 方法行格式化，相互独立，互不冲突，无法混用；
+2. 标准库的时间格式化语法自有特点，是不是感觉有点复杂；
+
+### 示例3，时间对象链式操作
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/gogf/gf/v2/os/gtime"
+    "time"
+)
+
+func main() {
+    // 去年今日，系统时间
+    fmt.Println(gtime.Now().AddDate(-1, 0, 0).Format("Y-m-d"))
+
+    // 去年今日，UTC时间
+    fmt.Println(gtime.Now().AddDate(-1, 0, 0).Format("Y-m-d H:i:s T"))
+    fmt.Println(gtime.Now().AddDate(-1, 0, 0).UTC().Format("Y-m-d H:i:s T"))
+
+    // 下个月1号凌晨0点整
+    fmt.Println(gtime.Now().AddDate(0, 1, 0).Format("Y-m-01 00:00:00"))
+
+    // 1个小时前
+    fmt.Println(gtime.Now().Add(-time.Hour).Format("Y-m-d H:i:s"))
+}
+```
+
+执行后，输出结果为：
+
+```
+2020-09-19
+2020-09-19 15:51:48 CST
+2020-09-19 07:51:48 UTC
+2021-10-01 00:00:00
+2021-09-19 14:51:48
+```
+
+该示例比较简单，便不多赘述。

package/skills/goframe-v2/references//347/273/204/344/273/266/345/210/227/350/241/250//347/263/273/347/273/237/347/233/270/345/205/263//346/227/266/351/227/264/347/256/241/347/220/206-gtime//346/227/266/351/227/264/347/256/241/347/220/206-/346/227/266/351/227/264/346/240/274/345/274/217.md

@@ -0,0 +1,45 @@
+:::warning
+注意事项： `gtime.Time` 对象通过 `Format` 方法来实现自定义格式的时间日期转换，该方法与标准库 `time.Time` 的 `Format` 方法冲突。在 `gtime.Time` 对象中，通过 `Layout` 方法实现标准库 `time.Time` 的 `Format` 格式，例如： ``t.Layout(`2006-01-02 15:04:05`)``。
+:::
+以下是 `gtime` 模块支持的时间格式语法列表：
+
+| 格式 | 说明 | 返回值示例 |
+| --- | --- | --- |
+| **日** | -- | -- |
+| `d` | 月份中的第几天，有前导零的 2 位数字 | 01 到 31 |
+| `D` | 星期中的第几天，文本表示，3 个字母 | Mon 到 Sun |
+| `N` | ISO-8601 格式数字表示的星期中的第几天 | 1（表示星期一）到 7（表示星期天） |
+| `j` | 月份中的第几天，没有前导零 | 1 到 31 |
+| `l` | ("L"的小写字母)星期几，完整的文本格式 | Sunday 到 Saturday |
+| `S` | 每月天数后面的英文后缀，2 个字符 | st，nd，rd 或者 th。可以和 j 一起用 |
+| `w` | 星期中的第几天，数字表示 | 0（表示星期天）到 6（表示星期六） |
+| `z` | 年份中的第几天 | 0 到 365 |
+| **周** | -- | -- |
+| `W` | ISO-8601 格式年份中的第几周，每周从星期一开始 | 例如：42（当年的第 42 周） |
+| **月** | -- | -- |
+| `F` | 月份，完整的文本格式 | January 到 December |
+| `m` | 数字表示的月份，有前导零 | 01 到 12 |
+| `M` | 三个字母缩写表示的月份 | Jan 到 Dec |
+| `n` | 数字表示的月份，没有前导零 | 1 到 12 |
+| `t` | 指定的月份有几天 | 28 到 31 |
+| **年** | -- | -- |
+| `Y` | 4 位数字完整表示的年份 | 例如：1999 或 2003 |
+| `y` | 2 位数字表示的年份 | 例如：99 或 03 |
+| **时间** | -- | -- |
+| `a` | 小写的上午和下午值 | am 或 pm |
+| `A` | 大写的上午和下午值 | AM 或 PM |
+| `g` | 小时，12 小时格式，没有前导零 | 1 到 12 |
+| `G` | 小时，24 小时格式，没有前导零 | 0 到 23 |
+| `h` | 小时，12 小时格式，有前导零 | 01 到 12 |
+| `H` | 小时，24 小时格式，有前导零 | 00 到 23 |
+| `i` | 有前导零的分钟数 | 00 到 59 |
+| `s` | 秒数，有前导零 | 00 到 59 |
+| `u` | 毫秒数(3位) | 例如：000, 123, 239 |
+| `U` | UNIX时间戳(秒) | 例如：1559648183 |
+| **时区** | -- | -- |
+| `O` | 与UTC相差的小时数 | 例如：+0200 |
+| `P` | 与UTC的差别，小时和分钟之间有冒号分隔 | 例如：+02:00 |
+| `T` | 时区缩写 | 例如：UTC，GMT，CST |
+| **日期** | -- | -- |
+| `c` | ISO 8601 格式的日期 | 例如：2004-02-12T15:19:21+00:00 |
+| `r` | RFC 822 格式的日期 | 例如：Thu, 21 Dec 2000 16:01:07 +0200 |

package/skills/goframe-v2/references//347/273/204/344/273/266/345/210/227/350/241/250//347/263/273/347/273/237/347/233/270/345/205/263//347/216/257/345/242/203/345/217/230/351/207/217-genv.md

@@ -0,0 +1,104 @@
+环境变量管理组件。
+
+**使用方式**：
+
+```go
+import "github.com/gogf/gf/v2/os/genv"
+```
+
+**接口文档**：
+
+[https://pkg.go.dev/github.com/gogf/gf/v2/os/genv](https://pkg.go.dev/github.com/gogf/gf/v2/os/genv)
+
+## `SetMap`
+
+```go
+func SetMap(m map[string]string) error
+```
+
+该方法用于批量设置环境变量。使用示例：
+
+```
+genv.SetMap(g.MapStrStr{
+    "APPID":     "order",
+    "THREAD":    "16",
+    "ENDPOINTS": "127.0.0.1:6379",
+})
+```
+
+## `GetWithCmd`
+
+```go
+func GetWithCmd(key string, def ...interface{}) *gvar.Var
+```
+
+该方法用于获取环境变量中指定的选项数值，如果该环境变量不存在时，则从命令行选项中读取。但是两者的名称规则会不一样。例如： `genv.GetWithCmd("gf.debug")` 将会优先去读取 `GF_DEBUG` 环境变量的值，当不存在时则去命令行中的 `gf.debug` 选项。
+
+需要注意的是参数命名转换规则：
+
+- 环境变量会将名称转换为大写，名称中的 `.` 字符转换为 `_` 字符。
+- 命令行中会将名称转换为小写，名称中的 `_` 字符转换为 `.` 字符。
+
+## `All`
+
+```go
+func All() []string
+```
+
+该方法表示返回环境变量中的字符串，并且以\` `key=value` \`的形式返回。
+
+## `Map`
+
+```go
+func Map() map[string]string
+```
+
+该方法表示返回环境变量中的字符串，并且以\` `map` \`的形式返回。
+
+## `Get`
+
+```go
+func Get(key string, def ...interface{}) *gvar.Var
+```
+
+该方法用于创建返回一个泛型类型的环境变量，如果给定的 `key` 不存在则返回一个默认的泛型类型的环境变量。
+
+## `Set`
+
+```go
+func Set(key, value string) error
+```
+
+该方法是通过存放 `key` 和 `value` 的环境变量，如果有报错则返回一个 `Error` 类型。
+
+## `SetMap`
+
+```go
+func SetMap(m map[string]string) error
+```
+
+该方法通过 `map` 类型的参数存放环境变量。
+
+## `Contains`
+
+```go
+func Contains(key string) bool
+```
+
+该方法通过检查环境变量中是否存在 `key`。
+
+## `Remove`
+
+```go
+func Remove(key ...string) error
+```
+
+该方法可以删除一个或者多个环境变量。
+
+## `Build`
+
+```go
+func Build(m map[string]string) []string
+```
+
+该方法将 `map` 的参数以数组的形式构建并且返回。

package/skills/goframe-v2/references//347/273/204/344/273/266/345/210/227/350/241/250//347/263/273/347/273/237/347/233/270/345/205/263//350/277/233/347/250/213/347/256/241/347/220/206-gproc//350/277/233/347/250/213/347/256/241/347/220/206-gproc.md

@@ -0,0 +1,24 @@
+## 基本介绍
+进程管理以及进程间的通信是通过 `gproc` 模块实现的，其中进程间通信采用的是本地socket通信机制。
+
+**使用方式**：
+
+```go
+import "github.com/gogf/gf/v2/os/gproc"
+```
+
+**接口文档**：
+
+[https://pkg.go.dev/github.com/gogf/gf/v2/os/gproc](https://pkg.go.dev/github.com/gogf/gf/v2/os/gproc)
+
+**简要说明：**
+
+1. `Manager` 对象为进程管理对象，可以同时管理多个子进程(当前执行进程为父进程)；
+2. `Process` 为进程对象，表示特定执行或者获取的一个进程资源；
+3. 我们可以通过 `Shell`、 `ShellExec`、 `ShellRun` 来执行Shell指令：
+   - `Shell` 表示一个原生的Shell指令执行方式，带自定义的输入和输出控制；
+   - `ShellExec` 执行命令后将会返回输出的结果内容；
+   - `ShellRun` 执行命令后将会直接将返回内容输出到标准输出；
+   - 我们可以使用 `goroutine` 来实现异步的执行，如： `go ShellRun(...)` 等等；
+
+## 相关文档

package/skills/goframe-v2/references//347/273/204/344/273/266/345/210/227/350/241/250//347/263/273/347/273/237/347/233/270/345/205/263//350/277/233/347/250/213/347/256/241/347/220/206-gproc//350/277/233/347/250/213/347/256/241/347/220/206-/344/277/241/345/217/267/347/233/221/345/220/254.md

@@ -0,0 +1,147 @@
+## 基本介绍
+
+`gproc` 组件提供了统一的信号监听和回调处理功能，目的是解决在程序中多个不同组件冗余的信号处理逻辑，以及接收退出信号后无法平滑析构的痛点。在没有统一退出信号监听的组件下，当多个组件通过 `goroutine` 异步监听信号，主 `goroutine` 接收到退出信号往往会直接退出，或者等待一段无法预测的时间退出，造成程序其实无法平滑退出，可能引起一些不可预料的问题。 `gproc` 通过统一的信号注册和回调处理，使得各个组件能够有效地接收到退出信号并做相应析构处理，使得程序的信号处理逻辑更加严谨。
+
+相关方法：
+
+```go
+// AddSigHandler adds custom signal handler for custom one or more signals.
+func AddSigHandler(handler SigHandler, signals ...os.Signal)
+
+// AddSigHandlerShutdown adds custom signal handler for shutdown signals:
+// syscall.SIGINT,
+// syscall.SIGQUIT,
+// syscall.SIGKILL,
+// syscall.SIGTERM,
+// syscall.SIGABRT.
+func AddSigHandlerShutdown(handler ...SigHandler)
+
+// Listen blocks and does signal listening and handling.
+func Listen()
+```
+
+简要介绍：
+
+- `AddSigHanlder` 方法用于添加对指定信号的监听和对应回调函数注册。
+- `AddSigHandlerShutdown` 方法用于添加对常见进程退出信号的监听和对应回调函数注册，可以注册多个 `SigHandler`。
+- `Listen` 方法用于阻塞监听信号并自动执行回调函数调用。
+
+我们来看两个示例。
+
+## 示例1，使用标准库信号监听
+
+使用标准库信号监听机制的常见代码逻辑如下：
+
+```go
+package main
+
+import (
+    "fmt"
+    "os"
+    "os/signal"
+    "syscall"
+    "time"
+)
+
+func signalHandlerForMQ() {
+    var (
+        sig          os.Signal
+        receivedChan = make(chan os.Signal)
+    )
+    signal.Notify(
+        receivedChan,
+        syscall.SIGINT,
+        syscall.SIGQUIT,
+        syscall.SIGKILL,
+        syscall.SIGTERM,
+        syscall.SIGABRT,
+    )
+    for {
+        sig = <-receivedChan
+        fmt.Println("MQ is shutting down due to signal:", sig.String())
+        time.Sleep(time.Second)
+        fmt.Println("MQ is shut down smoothly")
+        return
+    }
+}
+
+func main() {
+    fmt.Println("Process start, pid:", os.Getpid())
+    go signalHandlerForMQ()
+
+    var (
+        sig          os.Signal
+        receivedChan = make(chan os.Signal)
+    )
+    signal.Notify(
+        receivedChan,
+        syscall.SIGINT,
+        syscall.SIGQUIT,
+        syscall.SIGKILL,
+        syscall.SIGTERM,
+        syscall.SIGABRT,
+    )
+    for {
+        sig = <-receivedChan
+        fmt.Println("MainProcess is shutting down due to signal:", sig.String())
+        return
+    }
+}
+```
+
+我们通过 `go run` 命令来执行一下，随后通过 `Ctrl+C` 快捷键退出（ `Mac` 用户通过 `Command+C`）。
+
+```bash
+$ go run signal_handler.go
+Process start, pid: 21928
+^CMainProcess is shutting down due to signal: interrupt
+MQ is shutting down due to signal: interrupt
+```
+
+可以看到，好可惜，那个 `MQ` 的 `goroutine` 还没完全退出进程即被强行关闭。
+
+## 示例2，使用 `gproc` 信号监听
+
+使用 `gproc` 组件改进后的信号监听机制如下：
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/gogf/gf/v2/os/gproc"
+    "os"
+    "time"
+)
+
+func signalHandlerForMQ(sig os.Signal) {
+    fmt.Println("MQ is shutting down due to signal:", sig.String())
+    time.Sleep(time.Second)
+    fmt.Println("MQ is shut down smoothly")
+}
+
+func signalHandlerForMain(sig os.Signal) {
+    fmt.Println("MainProcess is shutting down due to signal:", sig.String())
+}
+
+func main() {
+    fmt.Println("Process start, pid:", os.Getpid())
+    gproc.AddSigHandlerShutdown(
+        signalHandlerForMQ,
+        signalHandlerForMain,
+    )
+    gproc.Listen()
+}
+```
+
+我们通过 `go run` 命令来执行一下，随后通过 `Ctrl+C` 快捷键退出（ `Mac` 用户通过 `Command+C`）。
+
+```bash
+$ go run signal_handler_gproc.go
+Process start, pid: 22876
+^CMQ is shutting down due to signal: interrupt
+MainProcess is shutting down due to signal: interrupt
+MQ is shut down smoothly
+```
+
+看到差别了吧！所有的信号监听函数都正常结束后，随后进程平滑退出。

package/skills/goframe-v2/references//347/273/204/344/273/266/345/210/227/350/241/250//347/263/273/347/273/237/347/233/270/345/205/263//350/277/233/347/250/213/347/256/241/347/220/206-gproc//350/277/233/347/250/213/347/256/241/347/220/206-/345/237/272/346/234/254/344/275/277/347/224/250.md

@@ -0,0 +1,110 @@
+## 执行Shell命令
+
+```go
+package main
+
+import (
+    "fmt"
+
+    "github.com/gogf/gf/v2/os/gctx"
+    "github.com/gogf/gf/v2/os/gproc"
+)
+
+func main() {
+    r, err := gproc.ShellExec(gctx.New(), `sleep 3; echo "hello gf!";`)
+    fmt.Println("result:", r)
+    fmt.Println(err)
+}
+```
+
+执行后，可以看到程序等待了3秒之后，输出结果为：
+
+```
+result: hello gf!
+
+<nil>
+```
+
+## 主进程与子进程
+
+由 `gproc.Manager` 对象创建的进程都默认带子进程标识，在子进程程序中可以通过 `gproc.IsChild()` 方法来判断自身是否为子进程。
+
+```go
+package main
+
+import (
+    "os"
+    "time"
+
+    "github.com/gogf/gf/v2/frame/g"
+    "github.com/gogf/gf/v2/os/gctx"
+    "github.com/gogf/gf/v2/os/gproc"
+)
+
+func main() {
+    var ctx = gctx.New()
+    if gproc.IsChild() {
+        g.Log().Printf(ctx, "%d: Hi, I am child, waiting 3 seconds to die", gproc.Pid())
+        time.Sleep(time.Second)
+        g.Log().Printf(ctx, "%d: 1", gproc.Pid())
+        time.Sleep(time.Second)
+        g.Log().Printf(ctx, "%d: 2", gproc.Pid())
+        time.Sleep(time.Second)
+        g.Log().Printf(ctx, "%d: 3", gproc.Pid())
+    } else {
+        m := gproc.NewManager()
+        p := m.NewProcess(os.Args[0], os.Args, os.Environ())
+        p.Start(ctx)
+        p.Wait()
+        g.Log().Printf(ctx, "%d: child died", gproc.Pid())
+    }
+}
+```
+
+执行后，终端打印结果如下：
+
+```html
+2018-05-18 14:35:41.360 28285: Hi, I am child, waiting 3 seconds to die
+2018-05-18 14:35:42.361 28285: 1
+2018-05-18 14:35:43.361 28285: 2
+2018-05-18 14:35:44.361 28285: 3
+2018-05-18 14:35:44.362 28278: child died
+```
+
+## 多进程管理
+
+`gproc` 除了能够创建子进程，管理子进程之外，也能管理非自身创建的其他进程。 `gproc` 可以同时管理多个进程，这里以单个进程为例来演示对进程的管理功能。
+
+1. 我们使用 `gedit` 软件(Linux下常用的文本编辑器)随意打开一个文件，在进程当中我们看到该gedit的进程ID为 `28536`
+
+```shell
+    $ ps aux | grep gedit
+    john  28536  3.6  0.6 946208 56412 ?  Sl  14:39  0:00 gedit /home/john/Documents/text
+```
+
+2. 我们的程序如下：
+
+```go
+package main
+
+import (
+       "fmt"
+
+       "github.com/gogf/gf/v2/os/gproc"
+)
+
+func main() {
+       pid := 28536
+       m := gproc.NewManager()
+       m.AddProcess(pid)
+       m.KillAll()
+       m.WaitAll()
+       fmt.Printf("%d was killed\n", pid)
+}
+```
+
+执行后， `gedit` 被关闭，终端输出信息为：
+
+```
+28536 was killed
+```