golang并发编程

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!")
}
}
}