package main
import (
    "fmt"
    "math/rand"
    "sync"
    "sync/atomic"
    "time"
)
func main() {
    // 此处状态是一个map
    var state = make(map[int]int)
    // 初始化锁
    var mutex = &sync.Mutex{}
    // 定义两个变量用于追踪读和写的总次数
    var readOps uint64 = 0
    var writeOps uint64 = 0
    // 启动100个goroutines读取状态值，每个goroutine耗时1毫秒
    for r := 0; r < 100; r++ {
        go func() {
            total := 0
            for {
                // 随机读取状态的某一个值
                // 1、加锁
                // 2、读取
                // 3、解锁
                key := rand.Intn(5)
                mutex.Lock()
                total += state[key]
                mutex.Unlock()
                // 次数自增1
                atomic.AddUint64(&readOps, 1)
    
                // 两次读取之间睡眠1毫秒
                time.Sleep(time.Millisecond)
            }
        }()
    }
    // 同上，启动10个goroutines模拟写操作
    // 随机给状态赋值，写操作次数自增1，睡眠1毫秒
    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.AddUint64(&writeOps, 1)
                time.Sleep(time.Millisecond)
            }
        }()
    }
    // 睡眠一秒等待读写操作
    // 打印出读写次数
    time.Sleep(time.Second)
    readOpsFinal := atomic.LoadUint64(&readOps)
    fmt.Println("readOps:", readOpsFinal)
    writeOpsFinal := atomic.LoadUint64(&writeOps)
    fmt.Println("writeOps:", writeOpsFinal)
    // 使用锁取出最后的状态值
    mutex.Lock()
    fmt.Println("state:", state)
    mutex.Unlock()
}

package main
import "fmt"
import "time"
import "sync/atomic"
func main() {
    // 使用无符号正整数用来表示计数
    var ops uint64 = 0
    // 为了模拟并发更新，我们启动50个goroutine，每个goroutine对计数自增1，大概1毫秒的耗时
    for i := 0; i < 50; i++ {
        go func() {
            for {
                // 使用AddUint64进行原子性的递增操作，将变量的地址作为参数传给该函数
                atomic.AddUint64(&ops, 1)
                
                // 睡眠1毫秒，模拟耗时
                time.Sleep(time.Millisecond)
            }
        }()
    }
    // 睡眠1秒进行若干累加操作
    time.Sleep(time.Second)
    // 由于计数器可能正在被其他goroutine进行累加操作，为了安全的获取计数值，我们通过LoadUint64函数获取计数器的一个拷贝，将计数器的内存地址给该函数
    opsFinal := atomic.LoadUint64(&ops)
    fmt.Println("ops: ", opsFinal)
}

package main
import "fmt"
import "time"
func main() {
    // 首先来看下基本的限速功能
    // 假设我们想限制对请求的处理
    // 我们将从同一个管道中提供这样的请求
    requests := make(chan int,  5)
    for i := 1; i <= 5; i++ {
        requests <- i
    }
    close(requests)
    // 该管道每200毫秒接收一个值
    // 这个是我们限速的核心
    limiter := time.Tick(time.Millisecond * 200)
    // 通过处理每个请求时管道接收值的阻塞，我们限制每200毫秒只处理一个请求
    for req := range requests {
        <-limiter
        fmt.Println("request", req, time.Now())
    }
    // 某些时候可能希望在保持整体限速规则下允许少量的请求不受限制
    // 可以通过含有缓冲区的管道来实现
    // burstyLimiter管道可以使同时处理的请求达到3个
    burstyLimiter := make(chan time.Time, 3)
    for i := 0; i < 3; i++ {
        burstyLimiter <- time.Now()
    }
    // 每200毫秒发送给burstyLimiter管道一个值
    go func() {
        for t := range time.Tick(time.Millisecond * 200) {
            burstyLimiter <- t
        }
    }()
    // 模拟5个新的请求，前三个请求由于burstyLimiter管道缓冲区的处理可以突破200毫秒的限制
    burstyRequests := make(chan int, 5)
    for i := 1; i <= 5; i++ {
        burstyRequests <- i
    }
    close(burstyRequests)
    for req := range burstyRequests {
        <-burstyLimiter
        fmt.Println("request", req, time.Now())
    }
}

package main
import "fmt"
import "time"
// 这个是工作进程，用来执行并发的任务
// 每个进程都会从管道jobs接受工作，并且将相应发送至管道results
// 每个工作我们都会睡眠一秒用以模拟一项耗时的任务
func worker(id int, jobs <-chan int, results chan<- int) {
    for j := range jobs {
        fmt.Println("worker", id, "started job", j)
        time.Sleep(time.Second)
        fmt.Println("worker", id, "finished job", j)
        results <- j * 2
    }
}
func main() {
    // 初始化两个管道用以给工作进程分配任务及接收结果
    jobs := make(chan int, 100)
    results := make(chan int, 100)
    // 启动三个工作进程
    // 此时它们是阻塞的，因为管道jobs是空的
    for w:= 1; w <= 3; w++ {
        go worker(w, jobs, results)
    }
    // 初始化5个任务
    // 关闭管道jobs，标识没有多余的任务了
    for j:= 1; j <= 5; j++ {
        jobs <- j
    }
    close(jobs)
    // 收集所有任务的结果
    for a := 1; a <= 5; a++ {
        <-results
    }
}

package main
import "time"
import "fmt"
func main() {
    // Ticker跟Timer是类似的机制:使用管道来通信
    // 下面示例中我们使用内置的for-range语句对于每500毫秒接收到一个的值进行迭代处理 
    ticker := time.NewTicker(time.Millisecond * 500)
    go func() {
        for t := range ticker.C {
            fmt.Println("Tick at", t)
        }
    }()
    // 跟Timer一样，Ticker也可以被停止
    // 当Ticker取消时，其相应的管道不会再接收到值
    // 该示例中我们在1600毫秒后停止
    time.Sleep(time.Millisecond * 1600)
    ticker.Stop()
    fmt.Println("Ticker stoped")
}

package main
import "time"
func main() {
    // Timer类似于未来一个独立的事件，可以告诉它你要等待多久，它会提供一个管道用来在时间点到时发出通知
    // 该例中会等待2秒
    timer1 := time.NewTimer(time.Second * 2)
    // <- timer1.C会一直阻塞直到时间过期管道发送出一个值
    <- timer1.C
    println("Timer1 expired")
    // 如果只是想等待一段时间，可以使用`time.Sleep`
    // 但使用timer你可以在时间到期前取消，这个也是Sleep做不到的
    timer2 := time.NewTimer(time.Second)
    go func() {
        <-timer2.C
        println("Timer2 expired")
    }()
    // 使用Stop来取消timer
    stop2 := timer2.Stop()
    if stop2 {
        println("Timer2 stopped")
    }
}

package main
import "fmt"
func main() {
    // 定义有两个字符串缓存区的channel queue
    // 我们将要迭代queue中的两个值
    queue := make(chan string, 2)
    queue <- "one"
    queue <- "two"
    close(queue)
    // range会迭代queue中接收到的每个值
    // 由于在上面已经close掉管道queue，所以在接收完两个值之和迭代就结束了
    for elem := range queue {
        fmt.Println(elem)
    }
}