1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

// 我是将 n 赋值为 1000 测的数据
func Sum(n int) {
    f, err := os.Create("text.txt")
    if err != nil {
       panic(err)
    }
    defer f.Close()
    a := 0
    t := time.Now()
    for i := 0; i < n; i++ {
       a++
    }
    fmt.Println(time.Since(t)) // output: 375ns

    t = time.Now()
    if _, err = f.WriteString("a"); err != nil {
       panic(err)
    }
    fmt.Println(time.Since(t)) // output: 22us
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// ConcurrentPrint 开启十个线程，每个线程都打印100次 a
func ConcurrentPrint() {
    for i := 0; i < 10; i++ {
       go Print()
    }
}

func Print() {
    for i := 0; i < 100; i++ {
       fmt.Println("a")
    }
}

1
2
3
4
5
6
7
8

func ConcurrentPrint() {
    for i := 0; i < 10; i++ {
       go func() {
          fmt.Printf("%d ",i)
       }()
    }
}
// output: 10 10 10 10 10 10 10 6 8 10

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

var a = 0

func ConcurrentAdd() {
    go Add()
    go Add()
}

func Add() {
    for i := 0; i < 10000; i++ {
       a++
    }
}

func TestConcurrentAdd(t *testing.T) {
    ConcurrentAdd()
    time.Sleep(time.Second)
    fmt.Println(a)
}

// output: 12269

1
2
3
4
5
6

for {
    /*屏蔽中断*/
    /*临界区*/
    /*启用中断*/
    ...
}

1
2
3
4
5
6

for{
    for lock != 0 {}
    lock = 1
    /*临界区*/
    lock = 0
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// 先比较 *addr 和 old 的值，如果相等就给 addr 赋值为 new，不相等就不操作
// 返回值为 addr 的值是否被改变
func compare_and_swap(addr *int, old, new int) (swapped bool){
    oldVal := *addr 
    if oldVal == old{
        *addr = new
        return true
    }
    return false
}

1
2
3
4
5
6

// 如果没有被交换，那就代表 lock 已经被其他线程占有了，所有需要等待
for{
    for !compare_and_swap(*lock,0,1) {} 
    /*临界区*/
    lock = 0
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

// A Locker represents an object that can be locked and unlocked.
type Locker interface {
    Lock()
    Unlock()
}

// A Mutex is a mutual exclusion lock.
// The zero value for a Mutex is an unlocked mutex.
//
// A Mutex must not be copied after first use.
//
// In the terminology of the Go memory model,
// the n'th call to Unlock “synchronizes before” the m'th call to Lock
// for any n < m.
// A successful call to TryLock is equivalent to a call to Lock.
// A failed call to TryLock does not establish any “synchronizes before”
// relation at all.
type Mutex struct {
    state int32
    sema  uint32
}

// Lock locks m.
// If the lock is already in use, the calling goroutine
// blocks until the mutex is available.
func (m *Mutex) Lock() {...}

// Unlock unlocks m.
// It is a run-time error if m is not locked on entry to Unlock.
//
// A locked Mutex is not associated with a particular goroutine.
// It is allowed for one goroutine to lock a Mutex and then
// arrange for another goroutine to unlock it.
func (m *Mutex) Unlock() {...}

1
2
3
4
5
6
7
8

var m sync.Mutex

for{
   m.Lock()
   /*临界区*/
   m.Unlock()
   ...
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

// Lock locks m.
// If the lock is already in use, the calling goroutine
// blocks until the mutex is available.
func (m *Mutex) Lock() {
    // Fast path: grab unlocked mutex.
    if atomic.CompareAndSwapInt32(&m.state, 0, mutexLocked) {
       if race.Enabled {
          race.Acquire(unsafe.Pointer(m))
       }
       return
    }
    // Slow path (outlined so that the fast path can be inlined)
    m.lockSlow()
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

// CounterCapacity 柜台的容量
// breadCount 面包的数量
var CounterCapacity, breadCount = 20, 0
var l sync.Mutex

// Eat 吃吃吃
func Eat() {
    for {
       l.Lock()
       // 柜台没面包了
       if !(breadCount > 0) {
          // 没面包肯定不能把柜台占着不让面包师放面包吧
          l.Unlock()
          continue
       }
       // 吃掉一个面包
       breadCount--
       fmt.Printf("吃")
       l.Unlock()
    }
}

// Make 做做做
func Make() {
    for {
       l.Lock()
       if !(breadCount < CounterCapacity) {
          // 柜台都满了肯定不能占着不让别人吃吧
          l.Unlock()
          continue
       }
       // 将一个面包放到柜台里面
       breadCount++
       fmt.Printf("做")
       l.Unlock()
    }
}

func Concurrent(){
    // 分别让三个人吃，三个人做
    for i := 0; i < 3; i++ {
        go Eat()
        go Make()
    }
    select {}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

// NewCond 传入一把锁返回一个条件变量
NewCond(l Locker) *Cond

// 调用 Wait 前务必保证已经获得了锁
// Wait 会让当前线程睡眠
// Wait 会释放锁
// 被唤醒的线程再次执行时会重新占有锁
Cond.Wait()

// Signal 会唤醒一个之前调用了 Wait 正在睡眠的线程
// 如果没有正在睡眠的线程就什么也不做
// 调用此方法不一定需要占有锁
Cond.Signal()

// Broadcast 会将所有之前调用了 Wait 正在睡眠的线程唤醒
// 调用此方法不一定需要占有锁
Cond.Broadcast()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

// CounterCapacity 柜台的容量
// breadCount 面包的数量
var CounterCapacity, breadCount = 1, 0
var l sync.Mutex

var cond = sync.NewCond(&l)

// Eat 吃吃吃
func Eat() {
    for {
       l.Lock()
       // 柜台没面包了
       if !(breadCount > 0) {
          cond.Wait()
       }
       // 吃掉一个面包
       breadCount--
       fmt.Printf("吃")
       cond.Signal()
       l.Unlock()
    }
}

// Make 做做做
func Make() {
    for {
       l.Lock()
       if !(breadCount < CounterCapacity) {
          cond.Wait()
       }
       // 将一个面包放到柜台里面
       breadCount++
       fmt.Printf("做")
       cond.Signal()
       l.Unlock()
    }
}

func Concurrent() {
    for i := 0; i < 2; i++ {
       go Eat()
       go Make()
    }
    select {}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

// Eat 吃吃吃
func Eat() {
    for {
       l.Lock()
       // 柜台没面包了
       if !(breadCount > 0) {
          condEat.Wait()
       }
       // 吃掉一个面包
       breadCount--
       fmt.Printf("吃")
       condMake.Signal()
       l.Unlock()
    }
}

// Make 做做做
func Make() {
    for {
       l.Lock()
       if !(breadCount < CounterCapacity) {
          condMake.Wait()
       }
       // 将一个面包放到柜台里面
       breadCount++
       fmt.Printf("做")
       condEat.Signal()
       l.Unlock()
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

// Eat 吃吃吃
func Eat() {
    for {
       l.Lock()
       // 柜台没面包了
       for !(breadCount > 0) {
          cond.Wait()
       }
       // 吃掉一个面包
       breadCount--
       fmt.Printf("吃")
       cond.Broadcast()
       l.Unlock()
    }
}

// Make 做做做
func Make() {
    for {
       l.Lock()
       for !(breadCount < CounterCapacity) {
          cond.Wait()
       }
       // 将一个面包放到柜台里面
       breadCount++
       fmt.Printf("做")
       cond.Broadcast()
       l.Unlock()
    }
}

1
2
3
4
5
6
7

l.Lock()
for !(condition) {
    cond.Wait()
}
work...
cond.Broadcast()
l.Unlock()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

type Semaphore struct {
    count int64
    ...
}

func InitSemaphore(n int64) *Semaphore {
    return &Semaphore{
       count: n,
    }
}

func (s *Semaphore) P() {
    s.count--
    if s.count < 0{
        s.sleep()
    }
}

func (s *Semaphore) V() {
    s.count++
    if s.count <= 0{
        s.signal()
    }
}

func (s *Semaphore) sleep() {...} 

func (s *Semaphore) signal() {...}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

func A(sem *Semaphore){
    work...
    sem.V()
}

func B(sem *Semaphore){
    sem.P()
    work...
}

func Concurrent(){
    sem := InitSemaphore(0)
    go A(sem)
    go B(sem)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

// CounterCapacity 柜台的容量
// breadCount 面包的数量
var CounterCapacity, breadCount = 1, 0
var l sync.Mutex

var semBread,semCounter = InitSemaphore(breadCount), InitSemaphore(CounterCapacity)

// Eat 吃吃吃
func Eat() {
    for {
       l.Lock()
       semBread.P()
       // 吃掉一个面包
       breadCount--
       fmt.Printf("吃")
       semCounter.V()
       l.Unlock()
    }
}

// Make 做做做
func Make() {
    for {
       l.Lock()
       semCounter.P()
       // 将一个面包放到柜台里面
       breadCount++
       fmt.Printf("做")
       semBread.V()
       l.Unlock()
    }
}

func Concurrent() {
    for i := 0; i < 2; i++ {
       go Eat()
       go Make()
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

// 通常使用 make 关键字来创建一个管道
// 创建管道时 make 接受一个必选参数和一个可选参数
// dataType 表示你想要创建的管道中可以丢什么类型的数据进去，如 int, string...
// 第二个是可选参数，为int 类型，代表你想创建的管道的缓冲区大小，通俗来讲就是管道有多长
ch := make(chan dataType) // 创建一个无缓冲的管道
ch := make(chan dataType,10) // 创建一个缓冲区为 10 的管道

// 往管道里面写
// 如果管道的缓冲区已经满了，那线程将会阻塞，直到有其他线程把管道里面的数据拿走空出了位置
// 如果是往无缓冲的管道写也视作缓冲区已满
ch <- yourData

// 从管道里面读
// 如果管道里面没有数据，那线程将会阻塞，直到有线程往管道里面写
v := <- ch
v,ok := <- ch // ok 表示是否从管道里面读取到值

// 关闭管道
// 往已经关闭的管道里面写数据会触发 panic，但是可以从已经关闭的管道里面读取数据
close(ch)

// 单向管道.  chan<- 只能往管道里面写，不能读.  <-chan 只能从管道里面读，不能写
// 我们可以在创建或者把管道当函数参数的时候将其设置为单向管道
ch := make(chan<- dataType) // 创建时设置成单向的我想不到有什么用
ch := make(<-chan dataType)

func FuncName(ch <-chan int){}
func FuncName(ch chan<- int){}

// 遍历
// 可以使用 range 遍历可读的管道
// 如果使用这个的话线程会停在这里，类似于监控 ch，直到 ch 被关闭才会继续往下执行
for v := range ch{
    handle...
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

ch := make(chan struct{})

func A(){
    work...
    ch <- data
    work...
}

func B(){
    work...
    data := <- ch
    work...
}

// A 和 B 会在操作管道的位置达成同步

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

ch1 := make(chan int)
ch2 := make(chan int)
...

go func() {
        for {
                v := <- ch1
                handleCh1(v)
        }
}()

go func() {
        for {
                v := <- ch2
                handleCh2(v)
        }
}()
...

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

ch1 := make(chan int)
ch2 := make(chan int)
...

// 注意 select 的 case 后面必须接与 channel 相关的操作
select {
    case v := <-ch1: handle(v)
    case v := <-ch2: handle(v)
    ...
}

1
2
3
4
5
6
7
8
9

// 单独使用一个 select 不带 case 可以阻塞当前线程让他不退出
select{}

// select 里面包一个 default 可以在没消息来的时候进入 default 那条路
select {
    case v := <-ch1: handle(v)
    case v := <-ch2: handle(v)
    default : ...
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

var a = 0
var m sync.Mutex

var wg sync.WaitGroup

func ConcurrentAdd() {
    wg.Add(2)
    go Add()
    go Add()
    wg.Wait()
    work...
}

func Add() {
    defer wg.Done()
    for i := 0; i < 10000; i++ {
       m.Lock()
       a++
       m.Unlock()
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

pool := sync.Pool{
    New: func() interface{} { 
        ...
        return YourObject
    },
}

// 因为返回的是一个空接口，所以一般需要类型断言
yourObj := pool.Get().(YourObjectType)
work...
// 注意：如果这里的对象是带有状态的，放回 Pool 之前一定要清除状态，否则有可能下次取到到这个带状态的对象
pool.Put(yourObj)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

var once sync.Once

func ReadConfig(){
    once.Do(func(){
        fmt.Printf("aaa")
    })
}

func main(){
    for i:=0;i<2;i++{
        ReadConfig()
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

// Load returns the value stored in the map for a key, or nil if no
// value is present.
// The ok result indicates whether value was found in the map.
func (m *Map) Load(key any) (value any, ok bool) {}

// Store sets the value for a key.
func (m *Map) Store(key, value any) {}

// LoadOrStore returns the existing value for the key if present.
// Otherwise, it stores and returns the given value.
// The loaded result is true if the value was loaded, false if stored.
func (m *Map) LoadOrStore(key, value any) (actual any, loaded bool) {}

// LoadAndDelete deletes the value for a key, returning the previous value if any.
// The loaded result reports whether the key was present.
func (m *Map) LoadAndDelete(key any) (value any, loaded bool) {}

// Delete deletes the value for a key.
func (m *Map) Delete(key any) {}

// Swap swaps the value for a key and returns the previous value if any.
// The loaded result reports whether the key was present.
func (m *Map) Swap(key, value any) (previous any, loaded bool) {}

// CompareAndSwap swaps the old and new values for key
// if the value stored in the map is equal to old.
// The old value must be of a comparable type.
func (m *Map) CompareAndSwap(key, old, new any) bool {}

// CompareAndDelete deletes the entry for key if its value is equal to old.
// The old value must be of a comparable type.
//
// If there is no current value for key in the map, CompareAndDelete
// returns false (even if the old value is the nil interface value).
func (m *Map) CompareAndDelete(key, old any) (deleted bool) {}

// Range calls f sequentially for each key and value present in the map.
// If f returns false, range stops the iteration.
//
// Range does not necessarily correspond to any consistent snapshot of the Map's
// contents: no key will be visited more than once, but if the value for any key
// is stored or deleted concurrently (including by f), Range may reflect any
// mapping for that key from any point during the Range call. Range does not
// block other methods on the receiver; even f itself may call any method on m.
//
// Range may be O(N) with the number of elements in the map even if f returns
// false after a constant number of calls.
func (m *Map) Range(f func(key, value any) bool) {}

1
2
3
4

func (*RWMutex) Lock // 写锁定
func (*RWMutex) Unlock // 写解锁
func (*RWMutex) RLock // 读锁定
func (*RWMutex) RUnlock // 读解锁

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

type Context interface {
    // 返回 context 的过期时间
    Deadline() (time.Time,bool) 
    // 返回一个 channel，这个 channel 会在 context 被取消后关闭
    // 多次调用 Done 会返回同一个 channel
    Done() <-chan struct{} 
    // Err 会返回 context 取消的原因，如果没被取消 Err 就返回 nil
    Err() error
    // Context 可以当一个 map 用，往里面放键值对，使用 Value 方法获取 key 对应的 value
    // 不建议使用 context 当 map 用，建议就只有一两个很简单的数据需要上下文传递的时候用一下
    Value(key any) any
}