Go标准库-进程、os、sync、atomic

type Process struct {
	Pid    int
	handle uintptr      // handle is accessed atomically on Windows
	isdone uint32       // process has been successfully waited on, non zero if true
	sigMu  sync.RWMutex // avoid race between wait and signal
}

func StartProcess(name string, argv []string, attr *ProcAttr) (*Process, error)

type ProcAttr struct {
    // 如果 Dir ⾮空，⼦进程会在创建 Process 实例前先进⼊该⽬录。（即设为⼦进程的当前⼯作⽬
    录）
    Dir string
    // 如果 Env ⾮空，它会作为新进程的环境变量。必须采⽤ Environ 返回值的格式。
    // 如果 Env 为 nil，将使⽤ Environ 函数的返回值。
    Env []string
    // Files 指定被新进程继承的打开⽂件对象。
    // 前三个绑定为标准输⼊、标准输出、标准错误输出。
    // 依赖底层操作系统的实现可能会⽀持额外的⽂件对象。
    // nil 相当于在进程开始时关闭的⽂件对象。
    Files []*File
    // 操作系统特定的创建属性。
    // 注意设置本字段意味着你的程序可能会执⾏异常甚⾄在某些操作系统中⽆法通过编译。这时候可以
    通过为特定系统设置。
    // 看 syscall.SysProcAttr 的定义，可以知道⽤于控制进程的相关属性。
    Sys *syscall.SysProcAttr
}

func FindProcess(pid int) (*Process, error)

 func (p *Process) Wait() (*ProcessState, error)

type ProcessState struct {
    pid int // The process's id.
    status syscall.WaitStatus // System-dependent status info.
    rusage *syscall.Rusage
}

package main

import (
	"fmt"
	"os"
	"os/exec"
	"path/filepath"
	"time"
)

func main() {
	if len(os.Args) < 2 {
		fmt.Printf("Usage: %s [command]\n", os.Args[0])
		os.Exit(1)
	}
	cmdName := os.Args[1]
	if filepath.Base(os.Args[1]) == os.Args[1] {
		if lp, err := exec.LookPath(os.Args[1]); err != nil {
			fmt.Println("look path error:", err)
			os.Exit(1)
		} else {
			cmdName = lp
		}
	}
	procAttr := &os.ProcAttr{
		Files: []*os.File{os.Stdin, os.Stdout, os.Stderr},
	}
	cwd, err := os.Getwd()
	if err != nil {
		fmt.Println("look path error:", err)
		os.Exit(1)
	}
	start := time.Now()
	process, err := os.StartProcess(cmdName, []string{cwd}, procAttr)
	if err != nil {
		fmt.Println("start process error:", err)
		os.Exit(2)
	}
	processState, err := process.Wait()
	if err != nil {
		fmt.Println("wait error:", err)
		os.Exit(3)
	}
	fmt.Println()
	fmt.Println("real", time.Now().Sub(start))
	fmt.Println("user", processState.UserTime())
	fmt.Println("system", processState.SystemTime())
}

输出

cmd             main.go         sort.go         time_test.go
cmd.go          ring.go         time.go         timer.go

real 6.30397ms
user 1.483ms
system 4.023ms

func LookPath(file string) (string, error)

// 例
str, err := exec.LookPath("/Users/AllWorkSpace/GoWorkSpace/src/base/")

type Cmd struct {
	// Path 是将要执⾏的命令路径。
    // 该字段不能为空（也是唯⼀⼀个不能为空的字段），如为相对路径会相对于 Dir 字段。
    // 通过 Command 初始化时，会在需要时调⽤ LookPath 获得完整的路径
	Path string

	// Args 存放着命令的参数，第⼀个值是要执⾏的命令（Args[0])；如果为空切⽚或者nil，使⽤ {Path} 运⾏。
    // ⼀般情况下，Path 和 Args 都应被 Command 函数设定
	Args []string


	// Env 指定进程的环境变量，如为 nil，则使⽤当前进程的环境变量，即 os.Environ()，⼀般就是当前系统的环境变量
	Env []string

	// Dir 指定命令的⼯作⽬录。如为空字符串，会在调⽤者的进程当前⼯作⽬录下执⾏
	Dir string
	// Stdin 指定进程的标准输⼊，如为 nil，进程会从空设备读取（os.DevNull）
    // 如果 Stdin 是 *os.File 的实例，进程的标准输⼊会直接指向这个⽂件
    // 否则，会在⼀个单独的 goroutine 中从 Stdin 中读数据，然后将数据通过管道传递到该命令中
    //（也就是从 Stdin 读到数据后，写⼊管道，该命令可以从管道读到这个数据）。在 goroutine 停⽌数据
    // 拷⻉之前（停⽌的原因如遇到EOF或其他错误，或管道的 write 端错误），Wait ⽅法会⼀直堵塞
	Stdin io.Reader

	// Stdout 和 Stderr 指定进程的标准输出和标准错误输出。
    // 如果任⼀个为 nil，Run ⽅法会将对应的⽂件描述符关联到空设备（os.DevNull）
    // 如果两个字段相同，同⼀时间最多有⼀个线程可以写⼊
	Stdout io.Writer
	Stderr io.Writer

	// ExtraFiles specifies additional open files to be inherited by the
	// new process. It does not include standard input, standard output, or
	// standard error. If non-nil, entry i becomes file descriptor 3+i.
	//
	// ExtraFiles is not supported on Windows.
	ExtraFiles []*os.File

	// SysProcAttr holds optional, operating system-specific attributes.
	// Run passes it to os.StartProcess as the os.ProcAttr's Sys field.
	SysProcAttr *syscall.SysProcAttr

	// Process is the underlying process, once started.
	Process *os.Process

	// ProcessState contains information about an exited process,
	// available after a call to Wait or Run.
	ProcessState *os.ProcessState

	ctx             context.Context // nil means none
	lookPathErr     error           // LookPath error, if any.
	finished        bool            // when Wait was called
	childFiles      []*os.File
	closeAfterStart []io.Closer
	closeAfterWait  []io.Closer
	goroutine       []func() error
	errch           chan error // one send per goroutine
	waitDone        chan struct{}
}

// CMD
func Command(namme string, agg ...strig)*Cmd

// Start
func (c *Cmd)Start() error

开始执⾏c包含的命令，但并不会等待该命令完成即返回。Wait⽅法会返回命令的退出状态码并在命令执⾏完后释放相关的资源。内部调⽤os.StartProcess，执⾏forkExec。


// Wait
func (c *Cmd)Wait() error

Wait会阻塞直到该命令执⾏完成，该命令必须是先通过Start执⾏。如果命令成功执⾏，stdin、stdout、stderr数据传递没有问题，并且返回状态码为0，⽅法的返回值为nil；如果命令没有执⾏或者执⾏失败，会返回*ExitError类型的错误；否则返回的error可能是表示I/O问题。如果c.Stdin不是*os.File类型，Wait会等待，直到数据从c.Stdin拷⻉到进程的标准输⼊。Wait⽅法会在命令返回后释放相关的资源。


//Output
// Output运行命令并返回其标准输出。
// 错误通常都是* ExitError类型。
//如果c.Stderr为nil，则Output填充ExitError.Stderr。
func (c *Cmd) Output() ([]byte, error)


//CombinedOutput
Output()只返回Stdout的结果，⽽CombinedOutput组合Stdout和Stderr的输出，即Stdout和Stderr都赋值为同⼀个bytes.Buffer。

除了上⾯介绍的Output和CombinedOutput直接获取命令输出结果外，还可以通过StdoutPipe返回io.ReadCloser来获取输出；相应的StderrPipe得到错误信息；⽽StdinPipe则可以往命令写⼊数据

func (c *Cmd) StdoutPipe() (io.ReadCloser, error)

StdoutPipe⽅法返回⼀个在命令Start执⾏后与命令标准输出关联的管道。Wait⽅法会在命令结束后会关闭这个管道，所以⼀般不需要⼿动关闭该管道。但是在从管道读取完全部数据之前调⽤Wait出错了，则必须⼿动关闭

func (c *Cmd) StderrPipe() (io.ReadCloser, error)

StderrPipe⽅法返回⼀个在命令Start执⾏后与命令标准错误输出关联的管道。Wait⽅法会在命令结束后会关闭这个管道，⼀般不需要⼿动关闭该管道。但是在从管道读取完全部数据之前调⽤Wait出错了，则必须⼿动关闭

func (c *Cmd) StdinPipe() (io.WriteCloser, error)

StdinPipe⽅法返回⼀个在命令Start执⾏后与命令标准输⼊关联的管道。Wait⽅法会在命令结束后会关闭这个管道。必要时调⽤者可以调⽤Close⽅法来强⾏关闭管道。例如，标准输⼊已经关闭了，命令执⾏才完成，这时调⽤者需要显示关闭管道

因为 Wait 之后，会将管道关闭，所以，要使⽤这些⽅法，只能使⽤ Start + Wait 组
合，不能使⽤ Run

package main

import (
	"bytes"
	"os/exec"
)

func main() {

}

func FillStd(name string, arg ...string) ([]byte, error){
	cmd := exec.Command(name, arg...)
	var out = new(bytes.Buffer)
	cmd.Stdout = out
	cmd.Stderr = out
	err := cmd.Run()
	if err != nil {
		return nil, err
	}
	return out.Bytes(), nil
}

func UseOutput(name string, arg ...string) ([]byte, error) {
	return exec.Command(name, arg...).Output()
}

func UsePipe(name string, arg ...string) ([]byte, error){
	cmd := exec.Command(name, arg...)
	stdout, err := cmd.StdoutPipe()
	if err != nil {
		return nil, err
	}
	if err = cmd.Start(); err != nil {

		return nil, err
	}
	var out = make([]byte, 0, 1024)
	for {
		tmp := make([]byte, 128)
		n, err := stdout.Read(tmp)
		out = append(out, tmp[:n]...)
		if err != nil {
			break
		}
	}
	if err = cmd.Wait(); err != nil {
		return nil, err
	}
	return out, nil
}

type User struct {
    Uid string // user id
    Gid string // primary group id
    Username string
    Name string
    HomeDir string
}

fmt.Println(user.Current())
fmt.Println(user.Lookup("yangping"))
fmt.Println(user.LookupId("0"))


&{501 20 yangping 杨平 /Users/yangping} <nil>
&{501 20 yangping 杨平 /Users/yangping} <nil>
&{0 0 root System Administrator /var/root} <nil>

cloneFlags = _CLONE_VM | /* share memory */
        _CLONE_FS | /* share cwd, etc */
        _CLONE_FILES | /* share fd table */
        _CLONE_SIGHAND | /* share sig handler table */
        _CLONE_THREAD /* revisit - okay for now */

func main() {
    i := 100
    fmt.Println(i) // 100
    p := (*int)unsafe.Pointer(&i)
    fmt.Println(*p) // 100
    *p = 0
    fmt.Println(i) // 0
    fmt.Println(*p) // 0
}

func Sizeof(v ArbitraryType) uintptr

func Offsetof(v ArbitraryType) uintptr

package main

import (
	"fmt"
	"unsafe"
)

type Datas struct {
	c0 byte
	c1 int
	c2 string
	c3 int
}

func main() {
	var d Datas
	fmt.Println(unsafe.Offsetof(d.c0)) // 0
	fmt.Println(unsafe.Offsetof(d.c1)) // 8
	fmt.Println(unsafe.Offsetof(d.c2)) // 16
	fmt.Println(unsafe.Offsetof(d.c3)) // 32
}

//返回结构体中某个field的对齐值（字节对齐的原因）
func Alignof(x ArbitraryType) uintptr

package main

import (
	"fmt"
	"unsafe"
)

type Datas struct {
	c0 byte
	c1 int
	c2 string
	c3 int
}

func main() {
	var x struct {
		a bool
		b int16
		c []int
	}

	/**
	  unsafe.Offsetof 函数的参数必须是一个字段 x.f, 然后返回 f 字段相对于 x 起始地址的偏移量, 包括可能的空洞.
	*/

	/**
	  uintptr(unsafe.Pointer(&x)) + unsafe.Offsetof(x.b)
	  指针的运算
	*/
	// 和 pb := &x.b 等价
	pb := (*int16)(unsafe.Pointer(uintptr(unsafe.Pointer(&x)) + unsafe.Offsetof(x.b)))
	*pb = 42
	fmt.Println(x.b) // "42"
}

type Locker interface {
    Lock()
    Unlock()
}

package main

import (
	"sync"
	"time"
)

type Human struct {
	tes  bool
	sex  bool
	age  uint8
	min  int
	name string
}

var m *sync.RWMutex
var val = 0

func main() {
	m = new(sync.RWMutex)
	go read(1)
	go write(2)
	go read(3)
	time.Sleep(5 * time.Second)
}

func read(i int) {
	m.RLock()
	time.Sleep(1 * time.Second)
	println("val", val)
	time.Sleep(1 * time.Second)
	m.RUnlock()
}

func write(i int) {
	m.Lock()
	val = 10
	time.Sleep(1 * time.Second)
	m.Unlock()
}


// 一般情况下

val : 0
val : 10

// keyBufPool returns []byte buffers for use by PickServer's call to
// crc32.ChecksumIEEE to avoid allocations. (but doesn't avoid the
// copies, which at least are bounded in size and small)
var keyBufPool = sync.Pool{
	New: func() interface{} {
		b := make([]byte, 256)
		return &b
	},
}
func (ss *ServerList) PickServer(key string) (net.Addr, error) {
	ss.mu.RLock()
	defer ss.mu.RUnlock()
	if len(ss.addrs) == 0 {
		return nil, ErrNoServers
	}
	if len(ss.addrs) == 1 {
		return ss.addrs[0], nil
	}
	bufp := keyBufPool.Get().(*[]byte)
	n := copy(*bufp, key)
	cs := crc32.ChecksumIEEE((*bufp)[:n])
	keyBufPool.Put(bufp)
	return ss.addrs[cs%uint32(len(ss.addrs))], nil
}

func main() {
	var once sync.Once
	onceBody := func() {
		fmt.Println("Only once")
	}
	for i := 0; i < 10; i++ {
		go func() {
			once.Do(onceBody)
		}()
	}
	time.Sleep(3e9)
}


只会打印一次 Only once

func main() {
    wp := new(sync.WaitGroup)
    wp.Add(10);
    for i := 0; i < 10; i++ {
    go func() {
    fmt.Println("done ", i)
    wp.Done()
    }()
    }
    wp.Wait()
    fmt.Println("wait end")
}

func main() {
    locker := new(sync.Mutex)
    cond := sync.NewCond(locker)
    done := false
    cond.L.Lock()
    go func() {
    time.Sleep(2e9)
    done = true
    cond.Signal()
    }()
    if (!done) {
    cond.Wait()
    }
    fmt.Println("now done is ", done);
}

这⾥当主goroutine进⼊cond.Wait的时候，就会进⼊等待，当从goroutine发出信号之后，主goroutine才会继续往下⾯⾛

package main

import (
	"fmt"
	"sync"
	"time"
)

var locker = new(sync.Mutex)
var cond = sync.NewCond(locker)

func test(x int) {
	cond.L.Lock()
	cond.Wait() // 等待通知 暂时阻塞
	fmt.Println(x)
	time.Sleep(time.Second * 1)
	cond.L.Unlock() // 释放锁，不释放的话将只会有⼀次输出
}
func main() {
	for i := 0; i < 40; i++ {
		go test(i)
	}
	fmt.Println("start all")
	cond.Broadcast() // 下发⼴播给所有等待的goroutine
	time.Sleep(time.Second * 60)
}

func (c *Cond) Wait() {
    c.checker.check()
    if raceenabled {
        raceDisable()
    }
    atomic.AddUint32(&c.waiters, 1)
    if raceenabled {
        raceEnable()
    }
    // 释放
    c.L.Unlock()
    runtime_Syncsemacquire(&c.sema)
    // 重新上锁
    c.L.Lock()
}

func CompareAndSwapInt32(addr *int32, old, new int32) (swapped bool)

func CompareAndSwapInt64(addr *int64, old, new int64) (swapped bool)

func CompareAndSwapPointer(addr *unsafe.Pointer, old, new unsafe.Pointer)
(swapped bool)

func CompareAndSwapUint32(addr *uint32, old, new uint32) (swapped bool)

func CompareAndSwapUint64(addr *uint64, old, new uint64) (swapped bool)

func CompareAndSwapUintptr(addr *uintptr, old, new uintptr) (swapped bool)

func AddInt32(addr *int32, delta int32) (new int32)

func AddInt64(addr *int64, delta int64) (new int64)

func AddUint32(addr *uint32, delta uint32) (new uint32)

func AddUint64(addr *uint64, delta uint64) (new uint64)

func AddUintptr(addr *uintptr, delta uintptr) (new uintptr)

func LoadInt32(addr *int32) (val int32)

func LoadInt64(addr *int64) (val int64)

func LoadPointer(addr *unsafe.Pointer) (val unsafe.Pointer)

func LoadUint32(addr *uint32) (val uint32)

func LoadUint64(addr *uint64) (val uint64)

func LoadUintptr(addr *uintptr) (val uintptr)

func StoreInt32(addr *int32, val int32)

func StoreInt64(addr *int64, val int64)

func StorePointer(addr *unsafe.Pointer, val unsafe.Pointer)

func StoreUint32(addr *uint32, val uint32)

func StoreUint64(addr *uint64, val uint64)

func StoreUintptr(addr *uintptr, val uintpt