并发编程
1、并行和并发
并行(parallel): 指同一时刻，有多条指令在多个处理器上执行
并发(concurrency): 指同一个时刻只能有一条指令执行，但多个进程指令被快速的轮换执行，使得宏观上具有多个 进程同时执行的效果，但是微观上并不是同时执行的，只是把时间分成若干段，使多个进程快速交替的执行。（时间片轮转）
Go 从语言层面就支持了并发，同时，并发程序的内存管理有时候是很复杂的，而 Go 语言提供了自动垃圾回收机制。
Go 语言为并发编程而内置了上层 API 基于 CSP（communicating sequential processes，顺序通信进程）模型。这就意味着显示锁都可以避免的，因为 Go 语言通过安全的通道发送和接受数据以实现同步，大大的简化了并发程序的编写。（CSP通信的方式实现同步而不是锁）
一般情况下，一个普通的桌面计算机跑十几二十个线程就有点负载过大了，但是同样这台机器却可以轻松的让成百上千甚至过万个 goroutine 进行资源竞争。
2、goroutine
goroutine 是 Go 并发设计的核心。goroutine 说到底就是协程，但是它比线程更小，十几个 goroutine 可能体现在底层就是五六个线程，Go 语言内部帮你实现了这些 goroutine 之间的内存共享。执行 goroutine 只需极少的栈内存（大概 4～5KB），当然会根据相应的数据伸缩。也正因为如此，可同时运行成千上万个并发任务。goroutine 比 thread 更易用、更高效、更轻便。
只需要在函数调用语句前添加 go 关键字，就可以创建并发执行单元。开发人员无需了解任何执行细节，调度器会自动将其安排到合适的系统线程上执行。
在并发编程里，我们通常想讲一个过程切分成几块，然后让每个 goroutine 各自负责一块工作。当一个程序启动时，其主函数即在一个单独的 goroutine 中运行，我们叫它 main goroutine。新的 goroutine 会用 go 语句来创建。
runtime.Goexit()： 退出此协程
runtime.GOMAXPROCS（n)：设置并行计算的 CPU 核数的最大值，并返回之前的值
runtime.Gosched(): 用于让出 CPU 时间片，让出当前 goroutine 的执行权限，调度器安排其他等待的任务运行，并在下次某个位置从该位置恢复执行。这就像接力赛，A 拍了一会碰到代码 runtime.Gosched() 就把接力棒交给 B 了，A 歇着 B 继续跑。
注意：
- 主协程退出了，其他子协程也要跟着退出
- 有可能主协程退出了，但是子协程还没来得及调用
package main
import (
"fmt"
"time"
"runtime"
)
func test() {
defer fmt.Println("aaa") // 终止协程，该语句仍然会被执行
// return // 终止此函数
runtime.Goexit() // 终止坐在的协程
fmt.Println("bbb")
}
func NewTask() {
// do something
}
func main() {
go newTask() // 新建一个协程，新建一个任务（只要看见一个 go 便创建一个协程)
// do something
}
多任务很容易出现资源竞争，就需要channel 做协程同步
2、channel
本质上就是一个管道
价值：
- 使用通信来共享数据
- 使用通信来同步
goroutine 运行在相同的地址空间，因此访问共享内存必须做好同步。gotoutine 奉行通过 CSP（通信） 来共享内存，而不是共享内存来通信。
引用类型 channel 是 CSP 模式的具体实现，用于多个 goroutine 通讯。其内部实现了同步，确保并发安全。
和 map 类似，channel 也一个对应 make 创建的底层数据结构的引用。
当我们复制一个 channel 或用于函数参数传递时，我们只是拷贝了一个 channel 的引用，因此调用者何时被调用者将引用同一个 channel 对象。和其他的引用类型一样，channel 的零值也是 nil。
定义一个 channel 时，也需要定义发送到 channel 的值的类型。channel 可以使用内置的 make() 函数来创建:
make (chan Type) // 无缓冲区，等价于 make (chan Type, 0)
make (chan Type, capacity) // 有缓冲区
当 capacity = 0 时，channel 是无缓冲阻塞读写的，当 capacity > 0 时，channel 有缓冲、是非阻塞的，直到写满 capacity 个元素才阻塞写入。
channel 操作符 <- 来接收和发送数据，发送和接收数据语法：
channel <- value // 发送 value 到 channel
<-channel // 接收并将其丢弃
x := <-channel // 从 channel 中接受数据，并赋值给 x
x, ok := <-channel // 同能同上，同时检查通道是否已关闭或者是否为空
默认情况下，channel 接收和发送数据都是阻塞的，除非另一端已经准备好，这样就使得 goroutine 同步变的更加的简单，而不需要显式的 lock
var ch make(chan int) // 定义通道
func person1() {
Printer("hello")
ch <- 666 // 给管道写数据，发送
}
func person2() {
<- ch // 从管道取数据，接收，如果通道没有数据他就会阻塞
Printer("world")
}
3、无缓冲和有缓冲 channel
无缓冲的通道(unbuffered channel)是值在接受前没有能力保存任何值的通道。
这种类型的通道要求发送 goroutine 和接收 goroutine 同时准备好，才能完成发送和接收操作。如果两个 goroutine 没有同时准备好，通道会导致先执行发送和接收操作的 gotoutine 阻塞等待。
这种对通道进行发送和接收的交互行为本身就是同步的。其中任意一个操作都无法离开另一个操作的单独存在。
在第 1 步，两个 goroutine 都到达通道，但哪个都没有开始执行或者接收。
在第 2 步，左侧的 goroutine 将它的手伸进了通道，这模拟了向通道发送数据的行为。这是，这个 goroutine 会在通道中被锁住，直到交换完成。
在第 3 步，右侧的 goroutine 将它的手放入通道，这模拟了从通道接收数据。这个 goroutine 一样会在通道中被锁住，直到交换完成。
在第 4 步和第 5 步，进行交换，并最终，在第 6 步，两个 goroutine 将他们的手从通道里拿出来，这模拟了被锁住的 goroutine 得到释放。两个 goroutine 现在都可以去做别的事情了。
无缓冲的 channel 创建格式：
make (chan Type) // 等价于 make(chan Type, 0)
0 表示容量，表示没有缓存，不能存东西
如果没有指定缓冲区容量，那么通道就是同步的，因此会阻塞到发送者准备好发送和接收着准备好接收。
有缓冲的通道和无缓冲的通道之间的一个很大的不同：无缓冲的通道保证进行发送和接收的 goroutine 会在同一时间进行数据交换：有缓冲的通道没有这种保证。
在第 1 步，右侧的 goroutine 正在从通道接收一个值。
在第 2 步，右侧的这个 goroutine 独立完成了接收值的动作，而左侧的 goroutine 正在发送一个新值到通道里。
在第 3 步，左侧的 goroutine 还在向通道发送新值，而右侧的 goroutine 正在从通道接收另外一个值。这个步骤里的两个操作既不是同步的，也不会互相阻塞。
最后，在第 4 步，所有的发送和接收都完成，而通道里还有几个值，也有一些空间可以存更多的值。
有缓冲的 channel 创建格式：
make(chan Type, capacity)
如果给定了一个缓冲区容量，通道就是异步的。只要缓冲区有未使用空间用于发送数据，或还包含可以接收的数据，那么其通信就是无阻塞地进行。
4、channel 关闭
- channel 不像文件一样需要经常去关闭，只有当你确实没有任何发送数据了，或者你想显示的结束 range 循环之类的，才去关闭 channel；
- 关闭 channel 后，无法向 channel 再发送数据（引发 panic 错误后导致接收立即返回零值）；
- 关闭 channel 后，可以继续向 channel 接收数据；
- 对于 nil channel，无论收发都会被阻塞
ch := make(chan int) // 创建一个无缓存的 channel
// 不需要写数据的时候，关闭 channel
cose(ch)
// 如果 ok 为 true，说明管道没有关闭
num, ok := <-ch
5、访问 channel 内容
- 迭代
- range
for num := range ch {
fmt.Println("num =", num)
}
6、单向的 channel
默认情况下，通道是双向的，也就是，既可以往里面发送数据也可以从里面接收数据。
但是，我们经常见一个通道作为参数进行传递而值希望对方是单向使用的，要么只让它发送数据，要么只让它接收数据，这时候我们可以指定通道的方向。
单向 channel 变量的声明非常简单，如下：
var ch1 chan int // ch1 是一个正常的 channel，不是单向的
var ch2 chan<- float64 // ch2 是单向 channel，只用于写 float64 数据
var ch3 <-chan int // ch3 是单向 channel，只用于读取 int 数据
- chan<- 表示数据进入管道，要把数据写进管道，对于调用者就是输出
- <-chan 表示数据从管道出来，对于调用者就是得到管道的数据，当然就是输入
可以将 channel 隐式转换为单向队列，只收或只发，不能将单向 channel 转换为普通 channel：
c := make(chan int, 3)
var send chan<- int = c // send-only
var revc <-chan int = c // receive-ony
send <- 1
<- recv
生产者消费者应用：
package main
import "fmt"
// 此通道只能写，不能读
func producer(in chan<- int) {
for i := 0; i < 10; i++ {
out <- i * I
}
}
// 此 channel 只能读，不能写
func consumer(out <-chan int) {
for num := range out {
fmt>Println("num = ", num)
}
}
func main() {
// 创建一个双向通道
ch := make(chan int)
// 生产者，生产数字，写入 channel
// 新开一个协程
go producer(ch) // channel 传参，引用传递
// 消费者，从 channel 读取内容，打印
consumer(ch)
}
7、Timer / Ticker 定时器
Timer 是一个定时器，代表未来的一个单一事件，你可以告诉 timer 你要等待多长时间，它提供一个 channel，在将来的那个时间那个 channel 提供了一个时间值。
// 创建定时器，2 秒后就会往 time 通道写内容（当前时间）
timer1 := timer.NewTimer(time.Second * 2)
fmt.Println("当前时间： ", time.Now())
// 2s 后，往 timer.C 写数据，有数据后，就可以读取
t := <-timer1.C
fmt.Printf("t= %V\n", t)
延迟：
// 定时2s，阻塞2s，2s后产生事件，往channel写内容
<-time.After(time.Second * 2)
停止和重置：
timer.Stop() // 停止定时器
timer.Reset(1 * time.Second) // 重新设置为 1 秒
Ticker 是一个定时触发的计时器，它会以一个间隔（interval）往 channel 发送一个事件（当前时间），而 channel 的接收者可以以固定的时间间隔从 channel 中读取事件
ticker := time.NewTicker(1 : time.Second)
i := 0
for {
<-ticker.C
I++
fmt.Println("i = ", i)
if i == 5 {
ticker.Stop()
break
}
}_
8、Select
Go 里面提供了一个关键字 select，通过 select 可以监听 channel 上的数据流动。
select 的用法和 switch 语言非常类似，由 select 开始一个新的选择块，每个选择条件由 case 语句来描述。
与 switch 语句可以选择任何可使用相等比较的条件相比，select 有比较多的限制，其中最大的一条限制就是每个 case 语句必须是一个 IO 操作，大致的结构如下：
select {
case <-chan1:
// 如果 chan1 成功读到数据，则进行该 case 处理语句
case chan2 <- 1:
// 如果成功向 chan 2 写入数据，则进行该 case 处理语句
default:
// 如果上面都没有成功，则进入 default 处理流程
}
在一个 select 语句中，Go 语言会按照顺序从头到尾评估每一个发送和接收的语句。
如果其中的任意一语句可以继续执行（即没有被阻塞），那么就从哪些可以执行的语句中任意选择一条来使用。
超时的实现：
import "time"
func main() {
ch := make(chan int)
quit := make(chan bool)
// 新开一个协程
go func() {
for {
select {
case num := <-ch:
fmt.Println("num = ", num)
case <-time.After(3 * time.Second)
fmt.Println("超时")
quit <- true
}
}()
}
for i := 0; i < 5; i++ {
ch <- I
time.Sleeep(time.Second)
}
<-quit
fmt.Println("程序结束")
}
网络概述、Socket 编程
1、网络协议
协议可以理解为规则，是数据传输和数据的解释的规则。
为了减少协议复杂性，大多数网络模型采用分层来组织。每一层都有自己的功能，每一层利用下一层提供的服务来为上一层提供服务，本层服务的实现细节对上层屏蔽。
越下面的层，越靠近硬件；越上面的层，越靠近用户。至于每一层叫什么名字，其实并不重要（除了辨识会问，哈哈）。但要具体指导每一层的作用。
OSI 七层协议：
- 物理层：主要是无力设备标准，如网线接口、光线接口。主要作用就是传输比特流，这一层的数据叫做比特。
- 数据链路层：定义如何让格式化数据数据以帧为单位进行传输，以及如何让控制对无力介质的访问。错误检测和纠正，保证数据的可靠传输。
- 网络层：位于不同位置两个主机系统提供连接和路径选择。(IP\ICMP\IGMP)
- 传输层：定义了一些传输数据的协议和端口号（WWW端口80等）。跟端口相关(TCP\UDP)
- 会话层：建立和维持会话（Session）
- 表示层：主要是提供格式化的表示和转换数据的服务。数据的压缩、加密、解密等都是在该层完成。
- 应用层：(FTP\Telnet\NFS)
几个常见协议：
- ARP: 通过 IP 地址找 MAC 地址
- RARP： 通过 MAC 地址找 IP 地址
- IP: 因特网互联协议
- TCP: Transmission Control Protocol, 是一种面向连接的、可靠的、基于字节流的传输层通信协议
- UDP: User Datagram Protocol, 是一种无连接的传输层协议，提供面向事务的简单不可靠信息传送服务。
- HTTP: 超文本传输协议
- ICMP: Internet Control Message Protocol, 因特网控制报文协议，用于在 IP主机、路由器之间的控制协议。
- IGMP: Internet Group Message Protocol，提供互联网多点传送的功能，即将一个 ip 包拷贝到多个 host
网络通信条件：
- 网卡：MAC 地址（不需要用户处理）：通过 IP 找 MAC
- 逻辑地址：IP 地址（需要用户指定），为了确定哪个电脑接收
- 端口：确定哪个程序接收
- 同一个程序/进程，只能绑定一个端口
- 不同系统，同一端口对应的程序可能不一样
2、Socket 编程
Socket 套接字，起源于 Unix，而 Unix 基本哲学之一就是“一切皆文件“，都可以用”打开 open -> 读写 write/read -> 关闭 close”。网络的 Socket 数据涮出是一种特殊的 IO，Socket 也是一种文件描述符。Socket 也具有一个类似于打开文件的函数调用：Socket()，该函数返回一个整型的 Socket 描述符，随后的连接建立、数据传输等操作都是通过该 Socket 实现的。
常见的 Socket 类型有两种：流式 Socket（SOCK_STREAM）和数据报式 Socket（SOCK_DGRAM）。流式是一种面向连接的 Socket，针对于面向连接的 TCP 服务应用；数据报式 Socket 是一种无连接的 Socket，对应于无连接的 UDP 服务应用。
C/S模型：
- 客户端（Client）： 主动请求服务
- 服务器（Server）：被动提供服务
B/S模型：
- 浏览器（Browser）：html
- 服务器（Server）
TCP 的 C/S 架构：
TCP 服务器
package main
import (
"fmt"
"net"
)
func main() {
// 监听
ln, err := net.Listen("tcp", ":127.0.0.1:8080")
if err != nil {
fmt.Println("err = ", err)
return
}
defer listener.Close()
// 阻塞等待用户连接
for {
conn, err := listener.Accept()
if err != nil {
fmt.Println("err = ", err)
continue
}
// 接收用户的请求
buf := make（[]byte, 1024）// 定义 1024 大小的缓冲区
n, err1 := conn.Read(buf)
if err1 != nil {
fmt.Println("errr1 = ", err1)
continue
}
fmt.Println("buf = ", string(buf[:n]))
}
defer conn.Close() // 关闭当前用户链接
}
TCP 客户端
package main
import (
"fmt"
"net"
)
func main() {
// 主动连接服务器
conn, err := net.Dial("tcp", "127.0.0.1:8000")
if err != nil {
fmt.Println("err = ", err)
return
}
defer conn.Close()
// 发送数据
conn.Write([]byte("are u ok?"))
}
3、Socket 并发
使用 goroutine 处理多个用户的 Socket 连接
// 处理用户请求
func HanleConn(conn net.Conn) {
// 函数调用完毕，自动关闭 conn
defer conn.Close()
// 获取客户端的网络地址信息
addr := conn.RemoteAddr().String()
// print addr
buf := make([]byte, 2048)
for {
// 读取用户数据
n, err := conn.Read(buf)
if err != nil {
// print err
return
}
// print n
// 输入 exit 退出连接
if "exit" == string(buf[:n]) {
// print addr
return
}
// 把数据转换为答谢，再发给用户
conn.Write([]byte(strings.ToUpper(string(buf[:n]))))
}
}
func main() {
// 监听
listen, err := net.Listen("tcp", "127.0.0.1:8000")
if err != nil {
// print err
return
}
defer listener.Close()
// 接收多个用户的请求
for {
conn, err := listener.Accept()
if err != nil {
// print err
return
}
// 处理用户请求，每来一个请求新建一个协程
go HandleConn(conn)
}
}
客户端多任务模式，即可以接受输入，也可以接受服务器 Socket 回复
func main() {
// 主动连接服务器
conn, err := net.Dial("tcp", "127.0.0.1:8000")
if err != nil {
// print err
return
}
// main 调用完毕，关闭连接
defer conn.Close()
go func {
// 从键盘输入内容，给服务器发送内容
str := nake([]byte, 1024)
for {
n, err := os.Stdin.Read(str) // 从键盘读取内容，放在 str
if err != nil {
// print err
return
}
// 把输入的内容发送给服务器
conn.Write(str[:n])
}
}()
// 接收服务器回复的数据
// 切片缓冲
buf := make([]byte, 1024)
for {
n, err := conn.Read(buf) // 接受的服务器的请求
if err != nil {
// print err
return
}
// print string(buf[:n])
}
}
4、使用 Socket 实现文件传输
获取文件属性
package main
import (
"fmt"
"os"
)
func main() {
list := os.Args
if len(list) != 2 {
// print useage: xxx file
return
}
fileName := list[1]
info, rr := os.Stat(fileName) // 获取文件属性
if err != nil {
// print err
return
}
// print info.Name(), info.Size()
}
文件发送端
package main
import (
"fmt"
"os"
"io"
"os"
)
func SendFile(path string, conn net.Conn) {
// 以只读方式打开文件
f, err := os.Open(path)
if err != nil {
// print err
return
}
defer f.Close()
// 读文件内容，读多少发送多少
buf := make([]byte, 1024 * 4)
for {
n, err := f.Read(buf)
if err != nil {
if err == io.EOF {
// 文件发送完成
} else {
print err
}
return
}
// 发送内容
conn.Write(buf[:n]) // 给服务器发送内容
}
}
func main() {
// 提示输入文件
// print
var path string
fmt.Scan(&path)
fileName := list[1]
info, rr := os.Stat(fileName) // 获取文件属性
if err != nil {
// print err
return
}
// 主动连接服务器
conn, err1 := net.Dial("tcp", "127.0.0.1:8000")
if err1 != nil {
// print err
return
}
defer conn.Close()
var n int
// 给发送方，先发送文件名
_, err = conn.Write([]byte(info.Name()))
if err != nil {
// print err
return
}
// 接收对方回复，如果回复ok，说明对方准备好，可以发送文件
var n int
buf := make([]byte, 1024)
n, err = conn.Read(buf)
if err != nil {
// print err
return
}
if "ok" == buf[:n] {
// 发送文件内容
SendFile(path, conn)
}
}
文件接收端
package main
import (
"fmt"
"os"
"io"
"os"
)
// 接收文件内容
func RecvFile(fileName string, conn net.Conn) {
// 新建文件
f, err := os.Create(fileName)
if err != nil {
// print err
return
}
buf := make([]byte, 1024 * 4)
// 接收多少，写多少
for {
n, err := conn.Read(buf)
if err != nil {
if err == io.EOF {
// 文件接收完毕
} else {
// print err
}
return
}
if n == 0 {
// 文件接收完毕
return
}
// 往文件写入内容
f.Write(buf[:n])
}
}
func main() {
// 监听
listener, err := net.Listen("tcp", "127.0.0.1:8000")
if err != nil {
// print err
return
}
defer listenner.Close()
// 阻塞等待用户连接
conn, err1 := listenner.Accept()
if err1 != nil {
// print err1
return
}
buf := make([]byte, 1024)
var n int
n, err2 = conn.Read(buf) // 读取对方发送的文件名
if err2 != nil {
// print errr2
return
}
defer conn.Close()
// fileName 保存一下
fileNmae := stirng(buf[:n])
// 回复 ok
conn.Write([]byte("ok"))
// 接收文件内容
Recv(fileName, conn)
}
5、使用 Socket 实现并发聊天室服务器
可以使用 NetCat 工具调试 Socket 连接
设计思路：
- map： 保存在线用户
type Client struct {
c chan string
Name string
Addr string
}
var onlineMap[string] Client
主协程：
- 处理用户连接
- 将用户加入 map
- 告诉所有在线用户，谁上线了
message <- 某个用户上线了
go 新开一个协程：
for {
msg := <-message // 如果有内容
// 遍历 map，看有多少个成员
for _, cli := range onlineMap {
cli.C <- msg
}
}
go 专门发送信息：
for msg := range cli.C {
write(msg)
}
go 专门接收用户的请求，把用户发过来的数据转发。用户发送过来的数据是 buf
mssage <- buf
对方下线，把当前用户从 map 中移除
具体实现：
main.go
package main
import (
"fmt"
"net"
"time"
)
type Client struct {
C chan string // 用于发送数据的管道
Name string // 用户名
Addr string // 网络地址
}
// 保存在线用户 cliAddr ===> Client
var onlineMap map[string]Client
// 消息
var massage = make(chan string)
// 新开一个协程，转发消息，只要有消息来了，就遍历 map，给 map 的每个成员发送消息
func Manager() {
for {
// 给 map 分配空间
onlineMap = make(map[string]Client)
msg := <-message // 没有消息前，这里会阻塞
// 遍历 map， 给 map 每个成员发送消息
for _, cli range onlineMap {
cli.C <- msg
}
}
}
// 给当前客户端发送信息
func WriteMsgToClient(cli Client, conn net.Conn) {
for msg := range cli.C {
conn.Write([]byte(msg + "\n"))
}
}
// 生成 msg
func MakeMsg(cli Client, msg string) (buf string) {
buf = "[" + cli.Addr + "]" + cli.Name + msg
}
// 处理用户连接
func HandleConn(conn net.Conn) {
// 获取客户端的网络地址
cliAddr := conn.RemoteAddr().String()
// 创建一个结构体, 默认，用户名和网络地址一样
cli := Client{make(chan string), cliAddr, cliAddr}
// 把结构体添加到 map
onlineMap[cliAddr] = cli
// 新开一个协程，专门给当前客户端发送信息
go WriteMsgToClient(cli, conn)
// 提示，我是谁
cli.C <- MakeMsg(cli, "I am here")
// 广播某个人在线
message <- "[" + cli.Addr + "]" + cli.Name + ": login"
message <- MakeMsg(cli, "login")
isQuit := make(chan bool) // 对方是否主动退出
hasData := make(chan bool) // 对方是否有数据发送
// 新建一个协程，接收用户发送过来的数据
go func() {
for {
buf := make([]byte, 2048)
n, err := conn.Read(buf)
if err != nil {
// print err
continue
}
// 对方断开或者出问题
if n == 0 {
isQuit <- true
// print err
return
}
// 转发此内容
msg := string(buf[:n])
if len(msg) == 3 && msg == "who" {
// who 消息，查询在线用户
conn.Write([]byte("user list:\n"))
for _, tmp := range onlineMap {
msg = tmp.Affr + ":" + tmp.Name + "\n"
conn.Write([]byte(msg))
}
} else if len(msg) >= 8 && msg[:6] == "rename" {
// rename 消息
name = strings.Split(msg, "|")[1]
cli.Name = name
onlineMap[cliAddr] = cli
conn.Write([]byte("rename ok \n"))
} else {
// 普通消息，直接转发
message <- MakeMsg(cli, msg)
}
// 表示有数据
hasData <- true
}
}()
for {
// 通过 select 检测 channel 的流动
select {
case <- isQuit:
// 当前用户从 map 移除
delete(onlineMap, cliAddr)
// 广播谁下线了
message <- MakeMsg(cli, "login out")
return
case <- hasData:
// 有数据，不处理
case <-time.After(60 * time.Second):
// 60s 之后超时处理
delete(onlineMap, cliAddr)
// 广播一下谁下线了
message <- MakeMsg(cli, "time out leave out")
return
}
}
}
func main() {
// 监听
listener, err := net.Listen("tcp", ":8000")
if err != nil {
// print err
return
}
defer listener.Close()
// 新开一个协程，转发消息，只要有消息来了，就遍历 map，给 map 的每个成员发送消息
go Manager()
// 主协程，循环阻塞等待用户连接
for {
conn, err := listener.Accept()
if err != nil {
// print err
continue
}
go HandleConn(conn) // 处理用户连接
}
}
HTTP 编程
1、Web 的工作方式
Web 服务器的工作原理可以简单地归纳为：
- 客户端通过 TCP/IP 协议建立到服务器的 TCP 连接
- 客户端向服务器发送 HTTP 协议请求包，请求服务器里的资源文档
- 服务器向客户端发送 HTTP 协议应答包，如果请求的资源包含有动态语言的内容，那么服务器会调用动态语言的解释引擎负责处理 “动态内容”，并将处理得到的数据返回给客户端
- 客户端与服务器断开。由客户端解释 HTML 文档，在客户端屏幕上渲染图形结果
2、HTTP 协议
HyperText Transfer Protocol, 超文本传输协议，详细规定了浏览器和万维网之间互相通信的规则，通过因特网传送万维网文档的数据传送协议。
HTTP 协议通常承载于 TCP 协议之上，有事也承载于 TLS 或 SSL 协议层之上，这个时候，就成了我们常说的 HTTPS
URL(Unique Resource Location) ，用来表示网络资源，可以理解为网络文件路径
3、常见请求方式
GET： 获取资源，不适合上传数据，参数显示在浏览器地址栏，保密性差
POST：用于提交数据，长度没有限制，数据放在请求正文中
4、请求和响应报文格式
请求格式:
#GET/ HTTP/1.1 // 请求行
Host: 127.0.0.1:8000 // 请求头
Connectin: keep-alive
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0(Windows NT 12.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) 6
Accept: text/html. application/xhtml+xml, application/xml; q=0.9, image/webp, */*; q=0.8
Accept-Encoding:gzip, defalte, sdch, br
Accept-Language:zh-CN, zh; q=0.8
// 空行
# // 包体
常见请求头：
User-Agent: 请求浏览器类型
Accept: 可是识别响应内容列表
Accept-Language: 可接收自然语言
Accept-Encoding: 可接收的编码压缩格式
Accept-Charset: 可接收的应答的字符集
Host: 请求的主机名，允许多个域名同处一个 IP 地址，即虚拟主机
connection: 连接方式：close / keepalive
Cookie: 存储于客户端拓展字段，向同一域名的服务器发送属于该域名的 cookie
响应报文：
#HTTP/1.1 200 OK // 状态头
Date: SUb, 28 Jan 2018 06:11:59 GMT // 状态行
Content-Length: 12
Content-Type: text/plain; charset=utf-8
hello world
常见状态码：
- 200 OK ：客户端请求成功
- 400 Bad Request：请求报文有语法错误
- 401 Unauthorized：未授权访问
- 403 Forbidden: 服务器拒绝服务
- 404 Nof Found: 资源不存在
- 500 Internal Server Error: 服务器内部错误
- 503 Server Unavailable: 服务器临时不能处理客户端请求
http 服务器响应示例：
package main
import (
"fmt"
"net/http"
)
// 服务器编写的业务逻辑处理程序
func myHandler(w http.ResponseWriter, r *http.Request) {
fmt.Fprintln(w, "hello world")
}
func main() {
http.HandleFunc("/go", myHandler)
// 在指定的地址进行监听，开启一个 HTTP
http.LisenAndServe("127.0.0.1:8000", nil)
}
5、HTTP 服务器编程
直接用 HTTP 内置的包实现 HTTP 服务器编程：
package main
import (
"fmt"
"net/http"
)
// w, 给客户端回复数据
// r, 读取客户端发送的数据
func HandConn(w http.ResponseWriter, r *Request) {
// r.URL 请求链接
// r.Method 请求的方式
// r.Body 请求体
// r.RomoteAddr 请求的 IP 地址
w.Write([]byte("hello go")) // 给客户端回复数据
}
func main() {
// 注册处理函数，用户联机额，自动调用指定的处理函数
http.HandleFunc("/", HandConn)
// 监听绑定
http:ListenAndServe(":8000", nil)
}
6、HTTP 客户端编程
package main
import (
"fmt"
"net/http"
)
func main() {
resp, err := http.Get("http://www.baidu.com")
if err != nil {
// print err
return
}
defer resp.Body.Close()
// print resp.Status, resp.StatusCode, resp.Header, resp.Body
// body 需要 io 的方式读取
var tmp string
buf := make([]byte, 4 * 1024)
for {
n, err := resp.Body.Read(buf)
if n == 0 {
// print err
break
}
tmp += string
}
// print tmp 网页内容
}
