如何上传织梦做的网站网站系统开发

一、goroutine

与传统的系统级线程和进程相比，协程的大优势在于其“轻量级”，可以轻松创建上百万个而不会导致系统资源衰竭，而线程和进程通常多也不能超过1万个。这也是协程也叫轻量级线程的原因。
golang原生支持并发编程
轻量级线程
非抢占式多任务处理，由协程主动交出控制权
编译器/解释器/虚拟机层面的多任务
多个协程可能在一个或多个线程上运行

1.1 go对协程的实现

goroutine--Go对协程的实现
go + 函数名：启动一个协程执行函数体

package mainimport ("fmt""time"
)func test_Routine() {fmt.Println("This is one routine!!!")
}func Add(x, y int) {z := x + yfmt.Println(z)
}func main() {for i := 1; i < 10; i++ {//启动一个协程执行函数体go Add(i, i)}//为避免并发执行后程序立即退出，先sleep 2秒time.Sleep(2)
}

package mainimport ("fmt""runtime""time"
)func main() {//定义一个数组var a [10]int//循环并发执行匿名函数，实现for i := 0; i < 10; i ++ {go func(i int) {for {a[i]++//主动让go协程让出时间片runtime.Gosched()}}(i)}time.Sleep(time.Millisecond)fmt.Println(a)
}

二、channel

Go语言在语言级别提供的goroutine间的通信方式
不要通过共享来通信，而要通过通信来共享。
channel的读写默认是阻塞的，除非有goroutine对其进行操作。

package mainimport ("fmt""strconv"
)//定义一个加法函数，传入x，y整型参数，quit整型通道
func Add(x, y int, quit chan int) {z := x + yfmt.Println(z)//发送 1 到channel quitquit <- 1
}//读取channel中的数据
func Read(ch chan int) {//将channel中数据发送出去，赋值给valuevalue := <-chfmt.Println("value:" + strconv.Itoa(value))
}//写数据到channel中
func Write(ch chan int) {//ch <- 10
}func main() {//ch := make(chan int)//go Read(ch)//go Write(ch)//time.Sleep(10)//fmt.Println("end of code")//定义一个容量为10的非阻塞整型通道切片，变 量名为chschs := make([]chan int, 10)//循环地给channel切片chs初始化for i := 0; i < 10; i++ {chs[i] = make(chan int)go Add(i, i, chs[i])}//遍历channel切片chs,并从channel中发出数据，留空for _, v := range chs {<-v}
}

三、缓冲channel

定义: c = make(chan int, n) n为缓冲区的大小，代表channel可以存储多少个元素，这几个元素可以无阻塞的写入，缓存的元素写满之后阻塞，除非有goroutine操作。

例子中定义一个容量为2的channel,

// 缓冲channel
package mainimport ("fmt""time"
)// 定义一个chnnel类型变量 ch
var ch chan int//测试buffered channel函数
func test_channel() {// 第一次发送常量1到channel chch <- 1fmt.Println("ch 1")// 第二次发送常量1到channel chch <- 1fmt.Println("ch 2")// 第三次发送常量1到channel chch <- 1fmt.Println("come to end goroutine 1")
}func main() {ch = make(chan int, 0) // 等价于 ch = make(chan int) 都是不带缓冲的channelch = make(chan int, 2) // 是带缓冲的channelgo test_channel()time.Sleep(2 * time.Second)fmt.Println("running end!")<-chtime.Sleep(time.Second)
}output:
ch 1
ch 2
running end!
come to end goroutine 1

package mainimport "fmt"func main() {c := make(chan int, 3   )//修改2为1就报错，修改2为3可以正常运行c <- 1c <- 2fmt.Println(<-c)fmt.Println(<-c)
}

四、select

Linux很早就引入的函数，用来实现非阻塞的一种方式。Go语言直接在语言级别支持select关键字，用于处理异步IO 问题。我们上面介绍的都是只有一个channel的情况，那么如果存在多个channel的时候，我们该如何操作呢，Go里面提供了一个关键字select，通过select可以监听channel上的数据流动。
select默认是阻塞的，只有当监听的channel中有发送或接收可以进行时才会运行，当多个channel都准备好的时候，select是随机的选择一个执行的。

package mainimport ("fmt""time"
)func main() {ch := make(chan int)//匿名函数，传入一个参数整型channel类型chgo func(ch chan int) {ch <- 1}(ch)time.Sleep(time.Second)select {//如果ch成功读到数据，则执行下面的语句case <-ch:fmt.Print("come to read ch!")default:fmt.Print("come to default!")}
}

// 实现超时控制
package mainimport ("fmt""time"
)func main() {ch := make(chan int)//定义一个channel timeouttimeout := make(chan int, 1)//定义一个匿名函数，用来实现超时控制go func() {time.Sleep( time.Second)timeout <- 1}()select {case <-ch:fmt.Print("come to read ch!\n")case <-timeout:fmt.Print("come to timeout!\n")}fmt.Print("end of code!")
}

// 使用time.After(time.Second)实现控制
package mainimport ("fmt""time"
)func main() {ch := make(chan int)select {case <-ch:fmt.Print("come to read ch!\n")case <-time.After(time.Second):fmt.Print("come to timeout!\n")}fmt.Print("end of code!")
}

// goroutine_2.go
package mainimport ("fmt""runtime""strconv""time"
)func main() {//协程1go func() {for i := 1; i < 100; i++ {if i == 10 {//主动出让cpu 使用的话 需要 导入 runtime包runtime.Gosched()}fmt.Println("routine 1:" + strconv.Itoa(i))}}()//协程2go func() {for i := 100; i < 200; i++ {fmt.Println("routine 2:" + strconv.Itoa(i))}}()time.Sleep(time.Second)
}