9、os

os包是Go语言标准库中一个非常重要的包，它提供了一系列用于操作系统交互的功能，使开发者可以方便地进行文件和目录操作、环境变量管理、进程管理、信号处理等。

环境变量

环境变量是操作系统用于传递配置信息的一种机制。在Go语言中，os包提供了一些函数用于读取、设置和删除环境变量。

读取环境变量

os.Getenv函数可以读取指定的环境变量。如果环境变量不存在，返回空字符串。

os.LookupEnv函数除了返回环境变量的值，还返回一个布尔值，表示环境变量是否存在。

package main

import (
    "fmt"
    "os"
)

func main() {
    // 读取环境变量
    value := os.Getenv("PATH")
    fmt.Println("PATH:", value)

    // 查找环境变量
    value, exists := os.LookupEnv("PATH")
    if exists {
        fmt.Println("PATH exists:", value)
    } else {
        fmt.Println("PATH does not exist")
    }
}

设置环境变量

使用os.Setenv函数可以设置指定的环境变量。如果环境变量已存在，其值将被更新：

package main

import (
    "fmt"
    "os"
)

func main() {
    // 设置环境变量
    err := os.Setenv("MY_VAR", "Hello, World!")
    if err != nil {
        fmt.Println("Error setting environment variable:", err)
        return
    }

    // 读取设置的环境变量
    value := os.Getenv("MY_VAR")
    fmt.Println("MY_VAR:", value)
}

删除环境变量

使用os.Unsetenv函数可以删除指定的环境变量：

package main

import (
    "fmt"
    "os"
)

func main() {
    // 设置环境变量
    err := os.Setenv("MY_VAR", "Hello, World!")
    if err != nil {
        fmt.Println("Error setting environment variable:", err)
        return
    }

    // 删除环境变量
    err = os.Unsetenv("MY_VAR")
    if err != nil {
        fmt.Println("Error unsetting environment variable:", err)
        return
    }

    // 读取删除的环境变量
    value := os.Getenv("MY_VAR")
    fmt.Println("MY_VAR:", value)  // 应该输出空字符串
}

进程管理

进程管理是操作系统的一项重要功能，os包提供了一些用于进程管理的函数，可以获取当前进程信息、创建子进程、进行进程间通信和同步。

获取当前进程信息

使用os.Getpid函数可以获取当前进程的ID。

使用os.Getppid函数可以获取当前进程的父进程ID。

package main

import (
    "fmt"
    "os"
)

func main() {
    pid := os.Getpid()
    ppid := os.Getppid()
    fmt.Println("Current Process ID:", pid)
    fmt.Println("Parent Process ID:", ppid)
}

创建子进程

StartProcess

package main

import (
    "fmt"
    "os"
)

func main() {
    // 子进程属性
    attrs := &os.ProcAttr{
        Files: []*os.File{
            os.Stdin,
            os.Stdout,
            os.Stderr,
        },
    }

    // 创建子进程
    process, err := os.StartProcess("/bin/ls", []string{"ls", "-l"}, attrs)
    if err != nil {
        fmt.Println("Error starting process:", err)
        return
    }

    // 等待子进程结束
    state, err := process.Wait()
    if err != nil {
        fmt.Println("Error waiting for process:", err)
        return
    }

    fmt.Println("Process state:", state)
}

Command

package main

import (
    "bytes"
    "fmt"
    "os/exec"
)

func main() {
    cmd := exec.Command("/bin/ls", "-l")

    // 捕获标准输出和标准错误
    var out bytes.Buffer
    var stderr bytes.Buffer
    cmd.Stdout = &out
    cmd.Stderr = &stderr

    err := cmd.Run()
    if err != nil {
        fmt.Println("Error:", err)
        fmt.Println("Stderr:", stderr.String())
        return
    }

    fmt.Println("Output:")
    fmt.Print(out.String())
}

获取命令执行结果

使用cmd.CombinedOutput函数可以同时获取命令的标准输出和标准错误：

package main

import (
    "fmt"
    "os/exec"
)

func main() {
    cmd := exec.Command("ls", "-l", "/nonexistent")
    output, err := cmd.CombinedOutput()
    if err != nil {
        fmt.Println("Error running command:", err)
        return
    }

    fmt.Println("Command Output:", string(output))
}

进程间通信

管道通信

使用os.Pipe函数可以创建一个用于进程间通信的管道。管道包含一个读取端和一个写入端：

package main

import (
	"fmt"
	"os"
	"os/exec"
)

func main() {
	// 创建管道
	r, w, err := os.Pipe()
	if err != nil {
		fmt.Println(err)
	}
	// 创建子进程
	command := exec.Command("grep", "hello")
	command.Stdout = os.Stdout
	command.Stdin = r
	// 开启子进程
	err = command.Start()
	if err != nil {
		fmt.Println(err)
	}
	// 向管道写入数据
	data := "hello world!\nthis is exec.command!"
	_, err = w.Write([]byte(data))
	if err != nil {
		fmt.Println(err)
	}
	// 关闭写入端
	w.Close()
	// 等待子进程结束
	err = command.Wait()
	if err != nil {
		fmt.Println(err)
	}
}

文件描述符传递

在Go语言中，可以通过os包进行文件描述符的传递，实现进程间通信：

package main

import (
    "fmt"
    "os"
    "os/exec"
)

func main() {
    // 创建管道
    r, w, err := os.Pipe()
    if err != nil {
        fmt.Println("Error creating pipe:", err)
        return
    }

    // 创建子进程
    cmd := exec.Command("cat")
    cmd.Stdin = r
    cmd.Stdout = os.Stdout

    if err := cmd.Start(); err != nil {
        fmt.Println("Error starting command:", err)
        return
    }

    // 向管道写入数据
    _, err = w.Write([]byte("hello world\n"))
    if err != nil {
        fmt.Println("Error writing to pipe:", err)
        return
    }
    w.Close()  // 关闭写入端

    // 等待子进程结束
    if err := cmd.Wait(); err != nil {
        fmt.Println("Error waiting for command:", err)
        return
    }
}

进程同步

在多进程编程中，进程同步是一个重要的问题。Go语言中可以使用os包的一些机制来实现进程同步，例如通过信号量或共享文件进行同步。

可以通过syscall包实现信号量来进行进程同步：

package main

import (
    "fmt"
    "os"
    "syscall"
)

func main() {
    sem := "/tmp/sem.lock"

    // 创建并打开信号量文件
    fd, err := os.OpenFile(sem, os.O_CREATE|os.O_RDWR, 0644)
    if err != nil {
        fmt.Println("Error opening semaphore file:", err)
        return
    }
    defer fd.Close()

    // 锁定信号量文件
    if err := syscall.Flock(int(fd.Fd()), syscall.LOCK_EX); err != nil {
        fmt.Println("Error locking semaphore file:", err)
        return
    }
    fmt.Println("Semaphore locked")

    // 解锁信号量文件
    if err := syscall.Flock(int(fd.Fd()), syscall.LOCK_UN); err != nil {
        fmt.Println("Error unlocking semaphore file:", err)
        return
    }
    fmt.Println("Semaphore unlocked")
}

信号处理

信号是操作系统用来通知进程发生异步事件的一种机制。Go语言的os包和os/signal包提供了处理系统信号的功能，允许程序捕获和响应各种系统信号。

捕获系统信号

使用os/signal包中的signal.Notify函数可以捕获系统信号（syscall包下定义）。

常见的信号包括：

SIGINT：中断信号

SIGTERM：终止信号

SIGHUP：挂起信号

package main

import (
    "fmt"
    "os"
    "os/signal"
    "syscall"
)

func main() {
    // 创建信号通道
    sigs := make(chan os.Signal, 1)

    // 注册要接收的信号
    signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)

    // 等待信号
    sig := <-sigs
    fmt.Println("Received signal:", sig)
}

自定义信号处理函数

package main

import (
    "fmt"
    "os"
    "os/signal"
    "syscall"
)

func main() {
    // 创建信号通道
    sigs := make(chan os.Signal, 1)

    // 注册要接收的信号
    signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)

    // 捕获信号并执行自定义处理函数
    go func() {
        sig := <-sigs
        fmt.Println("Received signal:", sig)
        cleanup()
        os.Exit(0)
    }()

    // 模拟长时间运行的任务
    fmt.Println("Running... Press Ctrl+C to exit.")
    select {}
}

// 自定义清理函数
func cleanup() {
    fmt.Println("Performing cleanup tasks...")
}

其他常用操作

用户与组信息获取

使用os/user包可以获取当前用户和组的信息，包括用户名、用户ID、组名和组ID等。

获取当前用户信息

使用user.Current函数可以获取当前用户的信息：

package main

import (
    "fmt"
    "os/user"
)

func main() {
    user, err := user.Current()
    if err != nil {
        fmt.Println("Error getting current user:", err)
        return
    }

    fmt.Println("Username:", user.Username)
    fmt.Println("User ID:", user.Uid)
    fmt.Println("Group ID:", user.Gid)
    fmt.Println("Home Directory:", user.HomeDir)
}

获取指定用户信息

使用user.Lookup函数可以根据用户名获取指定用户的信息：

package main

import (
    "fmt"
    "os/user"
)

func main() {
    user, err := user.Lookup("root")
    if err != nil {
        fmt.Println("Error looking up user:", err)
        return
    }

    fmt.Println("Username:", user.Username)
    fmt.Println("User ID:", user.Uid)
    fmt.Println("Group ID:", user.Gid)
    fmt.Println("Home Directory:", user.HomeDir)
}

系统时钟与时间管理

使用os包可以获取系统的当前时间，还可以通过time包来进行更多的时间操作。