golang并发编程

最新推荐文章于 2024-07-03 16:54:45 发布

csdn265

最新推荐文章于 2024-07-03 16:54:45 发布

阅读量586

点赞数

分类专栏： Golang

Golang 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

http://blog.csdn.net/e421083458/article/details/49739043

golang普通方法：

[plain]view plaincopy 
   
print?
 package main  
   
 import (  
     "fmt"  
 )  
   
 func rand_generator_1() int {  
     return rand.Int()  
 }  
   
 func main() {  
     fmt.Println(rand_generator_1())  
 }  

golang生成器：

[plain]view plaincopy 
   
print?
 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多路复用，高并发版生成器：

[plain]view plaincopy 
   
print?
 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技术

[plain]view plaincopy 
   
print?
 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之并发循环

[plain]view plaincopy 
   
print?
 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技术

[plain]view plaincopy 
   
print?
 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之共享变量

[plain]view plaincopy 
   
print?
 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之超时使用

[plain]view plaincopy 
   
print?
 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之默认值操作

[plain]view plaincopy 
   
print?
 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验证是否通道写满？

[plain]view plaincopy 
   
print?
 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之生产者消费者

[plain]view plaincopy 
   
print?
 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!")  
         }  
     }  
 }  
 
   
 
 
  
  
 
 
   
  http://blog.csdn.net/zhjih123/article/details/41604313 
  
 
 