ch8/ch8-02 #155
ch8/ch8-02
#155
giscus[bot]
bot
Replies: 6 comments 6 replies
-
练习8.1感觉自己实现的不是很好, 调试了很长时间, 因为对协程机制不是很熟悉, 我太小白了5555~_~、、、 package main
import (
"fmt"
"io"
"log"
"net"
"os"
"strings"
"sync"
"time"
)
// 定义一个*data类型切片
var dSlice []*data
func main() {
// 1. 从控制台读取要记录的时区服务器地址
// 2. 启动一个goroutine，每隔一秒钟向服务器发送一个请求，获取当前时间
// 3. 将服务器返回的时间输出到控制台
var wg sync.WaitGroup
wg.Add(len(os.Args[1:]))
// 获取服务器地址
// Tokyo=localhost:8020 London=localhost:8030
var server = make(map[int][]string)
for i, v := range os.Args[1:] {
// 处理输入
server[i] = strings.Split(v, "=")
}
// 启动时钟
for i, server := range server {
// 创建一个data类型的指针
dSlice = append(dSlice, new(data))
// 启动时钟
go clock(server[1], dSlice[i], &wg)
}
// 输出
// $ go run 8.1.go China=localhost:8000 Tokyo=localhost:8010
//====================================
//Tokyo localhost:8010 13:55:32
//China localhost:8000 12:55:32
// 输出前等待1s, 保证数据已经接收到并且写入到data类型的指针中
time.Sleep(1 * time.Second)
for {
fmt.Println("====================================")
for i, s := range server {
go output(s, dSlice[i])
}
time.Sleep(1 * time.Second)
}
// 尽管上面的死循环会阻塞主协程
// 但是还是写上吧
// 调试也方便
wg.Wait()
}
func output(ser []string, data *data) {
fmt.Println(ser[0], ser[1], data)
}
// data 类型
type data string
// 输出*data的时候，直接输出解引用data的值
func (d *data) String() string {
return string(*d)
}
// 实现Writer接口, 用于将数据写入到data类型的指针中
func (d *data) Write(p []byte) (n int, err error) {
// 写入数据
*d = data(p)
//fmt.Println(d)
return len(p), nil
}
// 编写监听多个服务器的时钟函数
func clock(server string, data *data, wg *sync.WaitGroup) {
defer wg.Done()
//fmt.Println(server)
conn, err := net.Dial("tcp", server)
if err != nil {
log.Fatal(err)
}
defer conn.Close()
mustCopy(data, conn)
}
func mustCopy(dst io.Writer, src io.Reader) {
if _, err := io.Copy(dst, src); err != nil {
log.Fatalln(err)
}
} |
Beta Was this translation helpful? Give feedback.
4 replies
-
|
对了方便测试, 我写了个配套的服务端程序 package main
import (
"flag"
"fmt"
"io"
"log"
"net"
"time"
)
// go run exampleClock.go -p 8010 -loc Asia/Tokyo
func main() {
// 设置flag
locstr := flag.String("loc", "Asia/Shanghai", "请输入完整的时区名称")
listenstr := flag.String("p", "8000", "请输入监听端口")
flag.Parse()
// 设置时区
loc, err := time.LoadLocation(*locstr)
if err != nil {
log.Fatal(err)
}
// 监听8000端口
listener, err := net.Listen("tcp", ":"+*listenstr)
if err != nil {
log.Fatal(err)
}
for {
conn, err := listener.Accept()
if err != nil {
log.Print(err) // e.g., connection aborted
continue
}
//handleConn(conn) // handle one connection at a time
// 在调用handleConn时加上go关键字，就可以同时处理多个客户端连接
go handleConn(conn, loc) // handle connections concurrently
}
}
var num = 0
func handleConn(c net.Conn, loc *time.Location) {
num++
defer c.Close()
fmt.Println("handleConn", num)
for {
_, err := io.WriteString(c, time.Now().In(loc).Format("15:04:05"))
if err != nil {
return // e.g., client disconnected
}
time.Sleep(1 * time.Second)
}
} |
Beta Was this translation helpful? Give feedback.
-
Beta Was this translation helpful? Give feedback.
-
|
你是大神了，这书我都不知道讲点什么玩意儿，这1年的Go白学了 |
Beta Was this translation helpful? Give feedback.
-
|
直接说问题比较好，抱怨也改变不了什么，毕竟开源社区大家都用爱发电。 PS：代码应该是原版保持一样的，中文翻译表达可能有待改进之处，欢迎提改进建议 |
Beta Was this translation helpful? Give feedback.
-
|
抱歉了，打扰到大佬了~B站里逛习惯了，感谢大佬翻译，我会控制下自己，把理解到的东西和补充发在评论区，再次感谢大佬回复，对于之前的评论深表歉意，您可以把没用的删掉
| |
zhangbest5
|
|
***@***.***
|
---- Replied Message ----
| From | ***@***.***> |
| Date | 1/13/2023 16:36 |
| To | ***@***.***> |
| Cc | ***@***.***> ,
***@***.***> |
| Subject | Re: [gopl-zh/gopl-zh.github.com] ch8/ch8-02 (Discussion #155) |
直接说问题比较好，抱怨也改变不了什么，毕竟开源社区大家都用爱发电。
PS：代码应该是原版保持一样的，中文翻译表达可能有待改进之处，欢迎提改进建议
—
Reply to this email directly, view it on GitHub, or unsubscribe.
You are receiving this because you commented.Message ID: ***@***.***>
|
Beta Was this translation helpful? Give feedback.
0 replies
-
8.1
server 服务端package main
import (
"flag"
"fmt"
"io"
"net"
"sync"
"time"
)
func main() {
var address string
// 通过命令行参数来获取端口
// flag来通过-port指定端口
flag.StringVar(&address, "port", ":8000", "端口号，默认8000")
flag.Parse()
fmt.Println(address)
// 开启服务
ListenAndServer(string(":" + address))
}
func ListenAndServer(address string) error {
// 建立连接（端口监听）
listener, err := net.Listen("tcp", address)
// 退出时关闭连接
//defer listener.Close()
if err != nil {
return err
}
// 等待组，防止函数退出时还有业务在执行
waitGroup := sync.WaitGroup{}
// 循环监听新连接（客户端连接）
for {
conn, err := listener.Accept()
// 新的连接等待组+1
waitGroup.Add(1)
if err != nil {
break
}
// 协程对应连接
go func(conn net.Conn) {
// 协程结束，等待组-1
defer waitGroup.Done()
// 向客户端写入时间以及当前服务器端口
io.WriteString(conn, time.Now().Format("15:04:05\n"))
}(conn)
}
waitGroup.Wait()
return nil
}client 客户端代码package main
import (
"io"
"net"
"os"
"strings"
"sync"
)
/*
时区id
China Standard Time
Eastern Standard Time
Hawaiian Standard Time
*/
func main() {
// 设置等待组
waitGroup := sync.WaitGroup{}
// 从命令行获取要访问的端口及其对应的时区
for _, val := range os.Args[1:] {
// 以等号分割
line := strings.Split(val, "=")
// 获取对应的时区及端口
tz, address := line[0], line[1]
// 等待组+1
waitGroup.Add(1)
go getTime(address, tz, &waitGroup)
}
waitGroup.Wait()
}
// 从指定服务器获取其时间
func getTime(address string, tz string, wait *sync.WaitGroup) {
// 等待组-1
defer wait.Done()
// 创建tcp client
conn, err := net.Dial("tcp", address)
if err != nil {
panic(err)
}
// 读取服务端发送过来的时间
time := make([]byte, 100)
conn.Read(time[:])
// 输出到标准输出流(时区=时间)
io.WriteString(os.Stdout, tz+"="+string(time)+"\n")
}启动程序，开多个终端启动 结果 |
Beta Was this translation helpful? Give feedback.
1 reply
-
|
提供一个 客户端版本， 不是很完美， 比楼上的好点 package main
import (
"fmt"
"io"
"log"
"net"
"os"
"strings"
"time"
)
func main() {
for _, val := range os.Args[1:] {
line := strings.Split(val, "=")
tz, address := line[0], line[1]
go getTime(tz, address)
}
for {
time.Sleep(1 * time.Second)
fmt.Print("\033[H\033[2J")
}
}
func getTime(tz, address string) {
conn, err := net.Dial("tcp", address)
if err != nil {
log.Fatal(err)
}
defer conn.Close()
mustCopy(os.Stdout, conn, tz)
}
func mustCopy(dst io.Writer, src io.Reader, tz string) {
buf := make([]byte, 4096)
for {
n, err := src.Read(buf)
if err != nil {
log.Fatal(err)
}
if n == 0 {
break
}
output := fmt.Sprintf("[%s] %s", tz, string(buf[:n]))
if _, err := dst.Write([]byte(output)); err != nil {
log.Fatal(err)
}
}
} |
Beta Was this translation helpful? Give feedback.
-
|
提供一个比较完美的版本， 支持不滚动刷新： 客户端 import ( var citySlice []city type city struct { func main() { } func printRow(city string, time *data) { func (d *data) String() string { func (d *data) Write(p []byte) (n int, err error) { func getTime(address string, data *data, wg *sync.WaitGroup) { func mustCopy(dst io.Writer, src io.Reader) { 显示效果如下： |
Beta Was this translation helpful? Give feedback.
1 reply
-
|
// 创建tcp client 这里后面不用defer conn.close 吗 |
Beta Was this translation helpful? Give feedback.
-
|
我来提供一个可以多次读取的版本，每次打印所有服务器的时间，一轮打完后再打下一轮 客户端 package main
import (
"fmt"
"log"
"net"
"sync"
"time"
)
type Server struct {
timeZone string
addr string
}
// CyclicBarrier的golang实现
// 功能类似于可循环使用的WaitGroup
type CyclicBarrier struct {
count int
waiting int
mutex sync.Mutex
cond *sync.Cond
}
func NewCyclicBarrier(count int) *CyclicBarrier {
cb := &CyclicBarrier{count: count}
cb.cond = sync.NewCond(&cb.mutex)
return cb
}
func (cb *CyclicBarrier) Await() {
cb.mutex.Lock()
defer cb.mutex.Unlock()
cb.waiting++
//到了一轮了
if cb.waiting == cb.count {
cb.waiting = 0
cb.cond.Broadcast() // 唤醒所有等待的协程
} else {
cb.cond.Wait() // 当前协程进入等待状态
}
}
var dataChan chan string
var barrier *CyclicBarrier
const LOOP_COUNT = 10
func main() {
//这里就直接初始化server了，不从os.Args或flag读了
servers := []Server{
{timeZone: "Shanghai",
addr: "127.0.0.1:8081"},
{timeZone: "NewYork",
addr: "127.0.0.1:8082"},
{timeZone: "London",
addr: "127.0.0.1:8083"},
{timeZone: "Tokyo",
addr: "127.0.0.1:8084"},
{timeZone: "HongKong",
addr: "127.0.0.1:8085"},
}
barrier = NewCyclicBarrier(len(servers) + 1)
dataChan = make(chan string, len(servers))
for _, server := range servers {
go conn(server)
}
for i := 0; i < LOOP_COUNT; i++ {
barrier.Await()
//一轮结束读取全部client写入chan的数据
for i := 0; i < len(servers); i++ {
fmt.Println(<-dataChan)
}
fmt.Print("==========================\n\n\n")
time.Sleep(2 * time.Second)
}
close(dataChan)
}
func conn(server Server) {
client, err := net.Dial("tcp", server.addr)
if err != nil {
log.Fatal(err)
}
defer client.Close()
for {
var data [100]byte
n, _ := client.Read(data[:])
dataChan <- server.timeZone + "===" + string(data[:n])
barrier.Await()
}
}服务端 package main
import (
"flag"
"log"
"net"
"strconv"
"time"
)
func main() {
port := flag.Int("p", -1, "port")
flag.Parse()
server, err := net.Listen("tcp", ":"+strconv.Itoa(*port))
if err != nil {
log.Fatal(err)
}
for {
conn, _ := server.Accept()
go handleConn(conn)
}
}
func handleConn(conn net.Conn) {
defer conn.Close()
for {
conn.Write([]byte(time.Now().Format("2006-01-02 15:04:05")))
time.Sleep(10 * time.Second)
}
}其中主要是用到了 type CyclicBarrier struct {
count int
waiting int
mutex sync.Mutex
release chan struct{}
}
func NewCyclicBarrier(count int) *CyclicBarrier {
return &CyclicBarrier{
count: count,
release: make(chan struct{}),
}
}
func (cb *CyclicBarrier) Await() {
cb.mutex.Lock()
cb.waiting++
if cb.waiting == cb.count {
cb.waiting = 0
close(cb.release)
cb.release = make(chan struct{})
cb.mutex.Unlock()
return
}
release := cb.release
cb.mutex.Unlock()
<-release
}思路是一样的，一个靠condition |
Beta Was this translation helpful? Give feedback.
0 replies
-
8.1服务器段8.1用户端 |
Beta Was this translation helpful? Give feedback.
0 replies
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Uh oh!
There was an error while loading. Please reload this page.
-
ch8/ch8-02
中文版
https://golang-china.github.io/gopl-zh/ch8/ch8-02.html
Beta Was this translation helpful? Give feedback.
All reactions