$ docker run -tid --net=bridge --name docker_bri1 \\
             ubuntu-base:v3
             docker run -tid --net=bridge --name docker_bri2 \\
             ubuntu-base:v3 

$ brctl show
$ docker exec -ti docker_bri1 /bin/bash
$ ifconfig –a
$ route –n

type Human struct {
	Name string
} 

var people = Human{Name:"zhangsan"}

package main

import (
	"fmt"
	"math/rand"
	"runtime"
	"sync"
	"sync/atomic"
	"time"
)

func main() {
	var state = make(map[int]int)
	var mutex = &sync.Mutex{}
	var ops int64 = 0
	for r := 0; r < 100; r++ {
		// 运行100个go协程来重复读取state
		go func() {
			total := 0
			for {
				key := rand.Intn(5)
				mutex.Lock()
				total += state[key]
				mutex.Unlock()
				atomic.AddInt64(&ops, 1)
				runtime.Gosched() // 为了确保这个Go协程不会在调度中饿死，我们在每次操作后明确的使用runtime.Gosched()进行释放。是自动处理的。
			}
		}()
	}
	for w := 0; w < 10; w++ { // 模拟写入操作
		go func() {
			for {
				key := rand.Intn(5)
				val := rand.Intn(100)
				mutex.Lock()
				state[key] = val
				mutex.Unlock()
				atomic.AddInt64(&ops, 1)
				runtime.Gosched()
			}
		}()
	}
	time.Sleep(time.Second)
	opsFinal := atomic.LoadInt64(&ops)
	fmt.Println("ops:", opsFinal)
	mutex.Lock() //对 state 使用一个最终的锁，显示它是如何结束的。
	fmt.Println("state:", state)
	mutex.Unlock()
}

func doSomething() {
    m.Lock()
    item := ...
    http.Get()  // 各种耗时的 IO 操作
    m.Unlock()
}

// 改为
func doSomething() {
    m.Lock()
    item := ...
    m.Unlock()

    http.Get()
}

// 非预期的在持有锁期间做 IO 操作
func doSomething() {
    m.Lock()
    defer m.Unlock()

    item := ...
    http.Get()  // 各种耗时的 IO 操作
}

	var mail = make(chan string)
    go func() {
        <- mail
        fmt.Println("get chance to do something")
    }()
    time.Sleep(5*time.Second)
    mail <- "moximoxi"

	sync.NewCond(&mutex)：生成一个cond，需要传入一个mutex，因为阻塞等待通知的操作以及通知解除阻塞的操作就是基于sync.Mutex来实现的。
	sync.Wait()：用于等待通知
	sync.Signal()：用于发送单个通知
	sync.Broadcat()：用于广播

package main

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

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

// NewCond(l Locker)里面定义的是一个接口,拥有lock和unlock方法。
// 看到sync.Mutex的方法,func (m *Mutex) Lock(),可以看到是指针有这两个方法,所以应该传递的是指针
func main() {
	for i := 0; i < 10; i++ {
		go func(x int) {
			cond.L.Lock()         // 获取锁
			defer cond.L.Unlock() // 释放锁
			cond.Wait()           // 等待通知，阻塞当前 goroutine
			// 通知到来的时候, cond.Wait()就会结束阻塞, do something. 这里仅打印
			fmt.Println(x)
		}(i)
	}
	time.Sleep(time.Second * 1) // 睡眠 1 秒，等待所有 goroutine 进入 Wait 阻塞状态
	fmt.Println("Signal...")
	cond.Signal() // 1 秒后下发一个通知给已经获取锁的 goroutine
	time.Sleep(time.Second * 1)
	fmt.Println("Signal...")
	cond.Signal() // 1 秒后下发下一个通知给已经获取锁的 goroutine
	time.Sleep(time.Second * 1)
	cond.Broadcast() // 1 秒后下发广播给所有等待的goroutine
	fmt.Println("Broadcast...")
	time.Sleep(time.Second * 5) // 睡眠 1 秒，等待所有 goroutine 执行完毕

}

package main

import (
	"fmt"
	"time"
)

var closeCh = make(chan struct{})

func main() {
	// var wg sync.WaitGroup
	fmt.Println("start main func")

	// wg.Add(1)
	go func() {
		fmt.Println("waiting for signal")
		<-closeCh
		fmt.Println("got signal.")
		// wg.Done()
	}()

	// wg.Add(1)
	go func() {
		fmt.Println("preparing for signal:")
		for i := 0; i < 3; i++ {
			fmt.Println(">>>>")
			time.Sleep(time.Second * 1)
		}
		closeCh <- struct{}{}
		fmt.Println("sent signal.")
		// wg.Done()
	}()
	// wg.Wait()
}

type Animal struct {
	Name string
}

type Old struct {
	Age int
}

func (a *Animal) Walk() {
	fmt.Println("Animal Walk")
}

 // 匿名嵌套，而且嵌套的是一个结构体指针
type People struct {
	*Animal
	Old
}
// 匿名嵌套，而且嵌套的是一个结构体
type People struct {
	Animal
	Old
}

type People struct {
	Animal Animal //非匿名嵌套Animal结构体
	Old
}

func NewPeople() *People {
	return &People{
		Animal: &Animal{Name: "bok"}, //嵌套结构体指针的方式，嵌套结构体时改成Animal: Animal{Name: "bok"} 即可
		Old:    Old{Age: 18},
	}
}

people := NewPeople()
people.Animal.Walk() // 访问父类的Walk
people.Walk() // 访问自己的Walk方法（从父类Animal那里继承过来的）
// Animal Walk
// Animal Walk

func (p *People) Walk() {
	fmt.Println("Poeple Walk")
}

people := NewPeople()
people.Animal.Walk() // 访问父类的Walk
people.Walk() // 访问自己的Walk方法（重写父类的Walk方法）
// Animal Walk
// Poeple Walk

package main

import "fmt"

type Animal struct {
	Name string
}

type Old struct {
	Age int
}

func (a *Animal) Walk() {
	fmt.Println("Animal Walk")
}

type People struct {
	*Animal
	Old
}

func (p *People) Walk() {
	fmt.Println("Poeple Walk")
}

func NewPeople() *People {
	return &People{
		Animal: &Animal{Name: "bok"},
		Old:    Old{Age: 18},
	}
}

func main() {
	people := NewPeople()
	people.Animal.Walk()
	people.Walk()
	fmt.Println(people.Age)
	fmt.Println(people.Name)
	fmt.Printf("New people %v \n", people)
}

hugo new posts/xxx.md

hugo -d /target/dir