golang普通方法:
package main import ( "fmt" ) func rand_generator_1() int { return rand.Int() } func main() { fmt.Println(rand_generator_1()) }
golang生成器:
package main import ( "fmt" "math/rand" ) /** * 生成器 * 根据已知权限使用函数生成相应数据,异步调用节省了大量时间。 * @author: niuyufu */ func rand_generator_1() int { return rand.Int() } //直接返回通道channel func rand_generator_2() chan int { //创建通道 out := make(chan int) //创建携程 go func() { //持续执行,直到程序被打断 for { //向通道内写入数据,如果无人读取会等待 out <- rand.Int() } }() return out } func main() { //生成随机数作为一个服务 rand_service_handler := rand_generator_2() //从服务中读取随机数并打印 fmt.Println("%dn", <-rand_service_handler) fmt.Println("%dn", <-rand_service_handler) fmt.Println("%dn", <-rand_service_handler) }
golang多路复用,高并发版生成器:
package main import ( "fmt" "math/rand" ) /** * 多路复用,高并发版生成器 * 根据已知权限使用函数生成相应数据,异步调用节省了大量时间。 * @author: niuyufu */ func rand_generator_1() int { return rand.Int() } //直接返回通道channel func rand_generator_2() chan int { //创建通道 out := make(chan int) //创建携程 go func() { //持续执行,直到程序被打断 for { //向通道内写入数据,如果无人读取会等待 out <- rand.Int() } }() return out } //函数 rand_generator_3,返回通道(channel) func rand_generator_3() chan int { //创建两个随机数生成器服务 rand_service_handler_1 := rand_generator_2() rand_service_handler_2 := rand_generator_2() //创建通道 out := make(chan int) //创建协程 go func() { for { //读取生成器1中的数据,整合 out <- <-rand_service_handler_1 } }() go func() { for { //读取生成器1中的数据,整合 out <- <-rand_service_handler_2 } }() return out } func main() { //生成随机数作为一个服务 rand_service_handler := rand_generator_3() //从服务中读取随机数并打印 fmt.Println("%dn", <-rand_service_handler) fmt.Println("%dn", <-rand_service_handler) fmt.Println("%dn", <-rand_service_handler) }
golang之Furture技术
package main import ( "fmt" ) /** * Furture技术 * 在不准备好参数的情况下调用函数:这样的设计可以提供很大的自由度和并发度, 参数调用与参数调用完全解耦 * @author: niuyufu */ //一个查询结构体 type query struct { //参数channel sql chan string //结果channel result chan string } //执行query func execQuery(q query) { //启动协程 go func() { //获取输入 sql := <-q.sql //访问数据库,输出结果通道 q.result <- "get " + sql }() } func main() { //初始化Query q := query{make(chan string, 1), make(chan string, 1)} //执行Query,注意执行的时候无需准备参数 execQuery(q) //准备参数 q.sql <- "select * from table" //获取结果 fmt.Println(<-q.result) }
golang之并发循环
package main import ( "fmt" ) /** * 并发循环 * 并发一次性跑完N个任务,这个牛X * @author: niuyufu */ func doSomething(i int, xi int) { fmt.Println("i=%d,xi=%d", i, xi) } func main() { //建立计数器 //这里就好比有好多一次性需要处理完的任务 data := []int{1, 2, 3, 1, 2, 3, 2, 3, 1, 2, 3, 2, 3, 1, 2, 3, 2, 3, 1, 2, 3, 2, 3, 1, 2, 3, 2, 3, 1, 2, 3, 2, 3, 1, 2, 3, 2, 3, 1, 2, 3, 2, 3, 1, 2, 3, 2, 3, 1, 2, 3, 2, 3, 1, 2, 3, 2, 3, 1, 2, 3, 2, 3, 1, 2, 3, 2, 3, 1, 2, 3} N := len(data) sem := make(chan int, N) //经过这个for可以让cpu占满来跑你的任务 for i, xi := range data { //建立协程 go func(i int, xi int) { doSomething(i, xi) //计数 sem <- 0 }(i, xi) } fmt.Println("并发循环开始") //等待结束,查看跑完结果 for i := 0; i < N; i++ { <-sem } fmt.Println("搞定了。") }
golang之Chain Filter技术
package main import ( "fmt" ) /** * Chain Filter技术 * 并发过滤链,每个通道只有两个协程访问,性能良好 * @author: niuyufu */ func Generate(ch chan<- int) { for i := 2; ; i++ { //fmt.Println("Generate:i:", i) ch <- i } } func Filter(in <-chan int, out chan<- int, prime int) { for { //只有输出才能再创建 i := <-in //fmt.Println("Filter:in pop:", i) if i%prime != 0 { //fmt.Println("Filter:out add:", i) out <- i } } } // func main() { //result数组 var numbers []int //channel大小为1 ch := make(chan int) go Generate(ch) //generate的gorouine占用channel:ch,通道被占用一次 for i := 0; i < 1000; i++ { prime := <-ch numbers = append(numbers, prime) fmt.Println(prime, "n") ch1 := make(chan int) go Filter(ch, ch1, prime) //Filter的gorouine也点用了channel:ch,通道被占用二次 ch = ch1 //打通两个通道 //fmt.Println(<-ch1) } //fmt.Printf("len=%d cap=%d slice=%v\n", len(numbers), cap(numbers), numbers) }
golang之共享变量
package main import ( "fmt" "time" ) /** * 共享变量 * 通过一个单独的协程来维护这两个通道。保证数据的一致性。 * @author: niuyufu */ //共享变量有一个读通道和一个写通道组成 type sharded_var struct { reader chan int writer chan int } //共享变量维护协程 func sharded_var_whachdog(v sharded_var) { go func() { //初始值 var value int = 0 for { //监听读写通道,完成服务 select { case value = <-v.writer: case v.reader <- value: } } }() } //超时避免阻塞 func never_leak(ch chan int) { //初始化timeout,缓冲为1 timeout := make(chan bool, 1) //启动timeout协程,由于缓存为1,不可能泄漏 go func() { time.Sleep(1 * time.Second) timeout <- true }() //监听通道,由于设有超时,不可能泄漏 select { case <-ch: // a read from ch has occurred case <-timeout: // the read from ch has timed out } } func main() { //初始化,并开始维护协程 v := sharded_var{make(chan int), make(chan int)} sharded_var_whachdog(v) //读取初始化 fmt.Println(<-v.reader) //写入一个值 v.writer <- 1 //读取新写入的值 fmt.Println(<-v.reader) }
golang之select之超时使用
package main import ( "fmt" "time" ) /** * select之超时使用 * select的使用,会随机从case中筛选可执行操作,如果没有能执行的操作则阻塞。 * 使用超时避免读阻塞,使用缓冲避免写阻塞 * @author: niuyufu */ func main() { timeout := make(chan bool, 1) ch := make(chan int) //每秒生产一下true数据 go func() { time.Sleep(1e9) //sleep one second timeout <- true }() select { case <-ch: fmt.Println("ch pop") case <-timeout: fmt.Println("timeout!") } }
golang之select之默认值操作
package main import ( "fmt" ) /** * select之默认值操作 * 没有能操作的case时,默认调用default操作 * @author: niuyufu */ func main() { ch1 := make(chan int, 1) ch2 := make(chan int, 1) //协程操作不仅能同步调用还能异步调用 ch1 <- 1 //同步 select { case <-ch1: fmt.Println("ch1 pop one element") case <-ch2: fmt.Println("ch2 pop one element") default: fmt.Println("default") } }
golang之select验证是否通道写满?
package main import ( "fmt" ) /** * select验证是否通道写满? * @author: niuyufu */ func main() { ch1 := make(chan int, 1) ch1 <- 1 select { case ch1 <- 2: fmt.Println("channel is not full !") default: fmt.Println("channel is full !") } }
golang之生产者消费者
package main import ( "fmt" "time" ) func main() { ch := make(chan int, 1) timeout := make(chan bool, 1) //生产者 go func() { for i := 0; i < 5; i++ { ch <- i fmt.Println("生产了:%d", i) } }() //消费者 var value int //设置最大操作数 for i := 0; i < 10; i++ { //每秒生产一下true数据 go func() { time.Sleep(10 * time.Microsecond) //sleep one second timeout <- true }() select { case value = <-ch: fmt.Println("消费了:%d", value) case <-timeout: fmt.Println("timeout!") } } }
版权声明:本文为博主原创文章,未经博主允许不得转载。
有疑问加站长微信联系(非本文作者)