ch8/ch8-10

[giscus[bot]]

ch8/ch8-10

中文版

https://gopl-zh.github.io/ch8/ch8-10.html

[zhangbest5]

实在无法理解，client 不是一个只能写入的string通道吗？然后书中代码就map那用了下，为何下面操作又变成双向？何必呢？还请有能理解的踢下我，谢谢

type client chan<- string // 只写入
var (
    entering = make(chan client) //变成了双向通道
    leaving  = make(chan client) //变成了双向通道
    messages = make(chan string) // 这是双向
)
func broadcaster() {
    clients := make(map[client]bool) // all connected clients
    ...

[iIlegalUser]

entering 和 leaving 通道的消息类型是一个只写的 string 通道（即 client ），但它们本身需要是双向的，因为 conn 需要将自己创建的双向 string 通道（ch）发送给 entering 和 leaving，同时 entering 和 leaving 需要读取消息并处理。这里的问题在于 conn 中创建的 ch 是双向通道，在通过 entering 发送时转换为了只写通道（即 client）并且存储在 map 中，虽然 map 中的 ch 是单向的，但是 conn 中的 ch 此时仍然是双向的，并且它们是同一个通道（还在学，不对的地方请指正）

[zhangbest5]

感谢回复

[Fu-LianPeng]

package main

import (
	"bufio"
	"fmt"
	"log"
	"net"
	"time"
)

const idleTime = 50 //unit minutes
// type client chan string
type client struct {
	clichan chan string
	name    string
}

var (
	message  = make(chan string, 10)
	entering = make(chan client)
	leaving  = make(chan client)
)

func broadcast() {
	table := make(map[client]bool)
	for {
		select {
		case mes := <-message:
			{
				for cli := range table {
					cli.clichan <- mes
				}
			}
		case cli := <-entering:
			{
				table[cli] = true
				cli.clichan <- fmt.Sprintln("we have ", len(table), " members:")
				for cling := range table {
					cli.clichan <- cling.name
				}
			}
		case cli := <-leaving:
			{
				delete(table, cli)
				close(cli.clichan)
			}
		}
	}
}
func main() {
	listener, err := net.Listen("tcp", "127.0.0.1:8080")
	if err != nil {
		log.Fatal(err)
	}
	go broadcast()
	for {
		conn, err := listener.Accept()
		if err != nil {
			log.Print(err)
		}
		go handle(conn)
	}
}
func idle(c net.Conn, reset <-chan struct{}) {
	ticker := time.NewTicker(time.Second)
	for i := 0; i < idleTime; i++ {
		select {
		case <-ticker.C:
		case _, ok := <-reset:
			if ok {
				i = 0
			} else { //在handle关闭reset以停止该runtime
				return
			}
		}
	}
	defer c.(*net.TCPConn).CloseRead()
}
func handle(c net.Conn) {
	defer c.Close()
	who := c.RemoteAddr().String()
	cli := client{clichan: make(chan string, 10), name: who}
	go handleWriter(c, cli.clichan) //可以接收消息了
	cli.clichan <- "you are " + who
	message <- who + " join us"
	entering <- cli //注册可以接收广播消息了
	reset := make(chan struct{})
	go idle(c, reset)
	scan := bufio.NewScanner(c)
	for scan.Scan() {
		reset <- struct{}{}
		message <- who + " say :" + scan.Text()
	}
	close(reset)
	leaving <- cli
	message <- who + " has leave"
	c.Close()
}
func handleWriter(c net.Conn, cli chan string) {
	for msg := range cli {
		fmt.Fprintln(c, msg)
	}
}

[minhamli]

两个东西不要弄混了，entering = make(chan client)，标识的是这个channel传递的类型是client，往这个里面放client类型的”变量“。而client的话：type client chan<- string，client这个类型的底层类型是一个只能往里面写的channel，传递类型是string。

[coderZoe]

make(chan T)这里的T你可以理解为泛型，用于明确这个chan可以接收和发送什么样的数据，比如make(chan string)那这个创建出的chan只能发送和接收string类型的数据，同理 entering = make(chan client)代表的是创建出了一个chan，这个chan只能发送和接收client类型的数据，并非是entering 的类型是client

[Zengyinjun]

package main

import (
	"bufio"
	"fmt"
	"log"
	"net"
	"time"
)

func main() {
	listener, err := net.Listen("tcp", "localhost:8000")
	if err != nil {
		log.Fatal(err)
	}
	go broadcaster()
	for {
		conn, err := listener.Accept()
		if err != nil {
			log.Print(err)
			continue
		}
		go handleConn(conn)
	}
}

type client chan<- string // an outgoing message channel
// 8.12
type clientChan struct {
	client
	name string
}

var (
	entering = make(chan clientChan)
	leaving  = make(chan clientChan)
	messages = make(chan string) // all incoming client messages
)

func broadcaster() {
	clients := make(map[clientChan]bool) // all connected clients
	for {
		select {
		case msg := <-messages:
			// Broadcast incoming message to all
			// clients' outgoing message channels.
			for cli := range clients {
				select {
				case cli.client <- msg:
					fmt.Println("send to " + cli.name)
				default:
					fmt.Println("pass " + cli.name)
				}
			}
		case cli := <-entering:
			clients[cli] = true
			str := "Online users:\n"
			for cli := range clients {
				str += (cli.name + "\n")
			}
			// only send to cli
			cli.client <- str
		case cli := <-leaving:
			delete(clients, cli)
			close(cli.client)
		}
	}
}
func handleConn(conn net.Conn) {
	ch := make(chan string) // outgoing client messages
	go clientWriter(conn, ch)
	ch <- "Input your name:"
	input := bufio.NewScanner(conn)
	var who string
	for input.Scan() {
		who = input.Text()
		break
	}
	// who := conn.RemoteAddr().String()
	ch <- "You are " + who
	// messages <- who + " has arrived"
	cc := clientChan{ch, who}
	entering <- cc
	tick := time.NewTicker(70 * time.Second)
	tickchan := make(chan struct{})
	go func() {
		for {
			select {
			case <-tickchan:
				tick = time.NewTicker(70 * time.Second)
			case <-tick.C:
				conn.Close()
				return
			}
		}
	}()
	// input := bufio.NewScanner(conn)
	for input.Scan() {
		tickchan <- struct{}{}
		messages <- who + ": " + input.Text()
	}
	// NOTE: ignoring potential errors from input.Err()

	leaving <- cc
	messages <- who + " has left"
	conn.Close()
}

func clientWriter(conn net.Conn, ch <-chan string) {
	for msg := range ch {
		// time.Sleep(5 * time.Second)
		fmt.Fprintln(conn, msg) // NOTE: ignoring network errors
	}
}

[shenhua4286]

//实现客户端 list通知
//客户端10秒不发消息，就退出
package main

import (
"bufio"
"fmt"
"log"
"net"
"time"
)

func main() {
listener, err := net.Listen("tcp", "localhost:8000")
if err != nil {
log.Fatal(err)
}
go broadcaster()
for {
conn, err := listener.Accept()
if err != nil {
log.Print(err)
continue
}
go handleConn(conn)
}
}

type client chan<- string // an outgoing message channel

type user struct {
ch client
name string
}

var (
entering = make(chan user)
leaving = make(chan user)
messages = make(chan string, 1) // all incoming client messages
)

func broadcaster() {
clients := make(map[user]bool) // all connected clients
for {
select {
case msg := <-messages:
// Broadcast incoming message to all
// clients' outgoing message channels.
for cli := range clients {
cli.ch <- msg
}
case cli := <-entering:
if len(clients) != 0 {
nowUser := "now clients :"
for cli := range clients {
nowUser += cli.name + ","
}
messages <- nowUser
}
clients[cli] = true
fmt.Printf("now : %+v", clients)
case cli := <-leaving:
delete(clients, cli)
close(cli.ch)
}
}
}

func handleConn(conn net.Conn) {
ch := make(chan string) // outgoing client messages
go clientWriter(conn, ch)

who := conn.RemoteAddr().String()
ch <- "You are " + who
messages <- who + " has arrived"
entering <- user{
	ch:   ch,
	name: who,
}

input := bufio.NewScanner(conn)

t := time.NewTicker(10 * time.Second)

isClose := make(chan string) // outgoing client messages

go func(conn net.Conn) {
	select {
	case _ = <-t.C:
		isClose <- "1"
	}
}(conn)

go func() {
	select {
	case _ = <-isClose:
		messages <- who + " has left"

		time.Sleep(time.Second)

		leaving <- user{
			ch:   ch,
			name: who,
		}
		conn.Close()
	}
}()

for input.Scan() {
	t.Reset(10 * time.Second)
	messages <- who + ": " + input.Text()
}

isClose <- "1";
// NOTE: ignoring potential errors from input.Err()

}

func clientWriter(conn net.Conn, ch <-chan string) {
for msg := range ch {
fmt.Fprintln(conn, msg) // NOTE: ignoring network errors
}
}

[shenhua4286]

实现客户端 list通知

客户端10秒不发消息，就退出

package main

import (
	"bufio"
	"fmt"
	"log"
	"net"
	"time"
)

func main() {
	listener, err := net.Listen("tcp", "localhost:8000")
	if err != nil {
		log.Fatal(err)
	}
	go broadcaster()
	for {
		conn, err := listener.Accept()
		if err != nil {
			log.Print(err)
			continue
		}
		go handleConn(conn)
	}
}

type client chan<- string // an outgoing message channel

type user struct {
	ch   client
	name string
}

var (
	entering = make(chan user)
	leaving  = make(chan user)
	messages = make(chan string, 1) // all incoming client messages
)

func broadcaster() {
	clients := make(map[user]bool) // all connected clients
	for {
		select {
		case msg := <-messages:
			// Broadcast incoming message to all
			// clients' outgoing message channels.
			for cli := range clients {
				cli.ch <- msg
			}
		case cli := <-entering:
			if len(clients) != 0 {
				nowUser := "now clients :"
				for cli := range clients {
					nowUser += cli.name + ","
				}
				messages <- nowUser
			}
			clients[cli] = true
			fmt.Printf("now : %+v", clients)
		case cli := <-leaving:
			delete(clients, cli)
			close(cli.ch)
		}
	}
}

func handleConn(conn net.Conn) {
	ch := make(chan string) // outgoing client messages
	go clientWriter(conn, ch)

	who := conn.RemoteAddr().String()
	ch <- "You are " + who
	messages <- who + " has arrived"
	entering <- user{
		ch:   ch,
		name: who,
	}

	input := bufio.NewScanner(conn)

	t := time.NewTicker(10 * time.Second)

	isClose := make(chan string) // outgoing client messages

	go func(conn net.Conn) {
		select {
		case _ = <-t.C:
			isClose <- "1"
		}
	}(conn)

	go func() {
		select {
		case _ = <-isClose:
			messages <- who + " has left"

			time.Sleep(time.Second)

			leaving <- user{
				ch:   ch,
				name: who,
			}
			conn.Close()
		}
	}()

	for input.Scan() {
		t.Reset(10 * time.Second)
		messages <- who + ": " + input.Text()
	}

	isClose <- "1";
	// NOTE: ignoring potential errors from input.Err()
}

func clientWriter(conn net.Conn, ch <-chan string) {
	for msg := range ch {
		fmt.Fprintln(conn, msg) // NOTE: ignoring network errors
	}
}

[coderZoe]

这节的示例还是挺有意思的，通过chan来抽象代理连接，通过chan <- msg 来代替conn.Write(msg)，核心其实就是

func clientWriter(conn net.Conn, ch <-chan string) {
    for msg := range ch {
        fmt.Fprintln(conn, msg) // NOTE: ignoring network errors
    }
}

向chan内写数据的时候，会被for msg := range ch消费到，然后再通过fmt.Fprintln(conn, msg)真实的调conn写出去。

练习8.12 修改client，用结构体包一下，包含客户端信息，在enter的时候将这些客户端信息写出即可：

package main

import (
	"bufio"
	"fmt"
	"log"
	"net"
)

type client struct {
	who  string
	conn chan<- string
}

var (
	entering = make(chan client)
	leaving  = make(chan client)
	message  = make(chan string)
)

func main() {

	server, err := net.Listen("tcp", ":44567")
	if err != nil {
		log.Fatal(err)
	}
	//广播
	go broadcaster()
	for {
		conn, _ := server.Accept()
		go handleConn(conn)
	}
}

// 广播
func broadcaster() {
	//所有的客户端
	clients := make(map[client]bool)

	for {
		select {
		case msg := <-message:
			for client := range clients {
				client.conn <- msg
			}
		case cli := <-entering:
			for others := range clients {
				cli.conn <- others.who
			}
			clients[cli] = true

		case cli := <-leaving:
			delete(clients, cli)
			close(cli.conn)
		}
	}
}

func handleConn(conn net.Conn) {
	defer conn.Close()
	ch := make(chan string)
	who := conn.RemoteAddr().String()
	go clientWriter(conn, ch)

	//先给大家发消息，再将自己加入clients 避免发给自己
	message <- who + "has arrived"
	client := client{who: who, conn: ch}
	entering <- client

	//单发给自己消息
	ch <- "welcome " + who

	input := bufio.NewReader(conn)
	//一旦读到客户端发来的消息，就通过message 广播出去

	var buf [64 * 1024]byte
	for {
		len, err := input.Read(buf[:])
		if err != nil {
			break
		}
		message <- who + ": " + string(buf[:len])
	}

	//先离开 再发消息给大家避免发给自己
	leaving <- client
	message <- who + "has leaf"
}

func clientWriter(conn net.Conn, ch <-chan string) {
	for msg := range ch {
		fmt.Fprintln(conn, msg)
	}
}

练习8.15 ，可以广播写出的时候加个最长等待时间，要是还没写出就不管了，直接写下一个客户端：

		for {
		select {
		case msg := <-message:
			for client := range clients {
				select {
				case client.conn <- msg:
					//do nothing
				case <-time.After(5 * time.Second):
					fmt.Println("write to" + client.who + "timeout")
				}
			}
		case cli := <-entering:
			for others := range clients {
				cli.conn <- others.who
			}
			clients[cli] = true

		case cli := <-leaving:
			delete(clients, cli)
			close(cli.conn)
		}
	}

[fcmwf]

8.12 、8.13
package main

import (
"bufio"
"bytes"
"fmt"
"log"
"net"
"time"
)

//!+broadcaster
type client struct{
path chan string // an outgoing message channel
name string
alive chan struct{}
conn net.Conn
}

var (
clients = make(map[client]bool) // all connected clients
entering = make(chan client)
leaving = make(chan client)
messages = make(chan string) // all incoming client messages
maxWaitTime = uint(10)
)

func broadcaster() {

for {
	select {
	case msg := <-messages:
		// Broadcast incoming message to all
		// clients' outgoing message channels.
		for cli := range clients {
			cli.path <- msg
		}

	case cli := <-entering:
		clients[cli] = true

	case cli := <-leaving:
		delete(clients, cli)
		close(cli.path)
	}
}

}
//!-broadcaster

func getCurConn() string{
var buf bytes.Buffer
buf.WriteString("current connection:\n")
for client := range clients{
buf.WriteString(client.name+"\n")
}
return buf.String()
}

func routineIdle(client* client){
defer client.conn.(*net.TCPConn).Close()

tick := time.Tick(1 * time.Second)
for i := 0; i <= int(maxWaitTime); i++{
	select{
	case <- tick:
		fmt.Printf("name:%s, time:%v\n",client.name,i)
	case <-client.alive:
			i = 0
	}
}

}

//!+handleConn
func handleConn(conn net.Conn) {
ch := client{
path: make(chan string),
conn: conn,
alive: make(chan struct{}),
}

go clientWriter(conn, &ch)
go routineIdle(&ch)

who := conn.RemoteAddr().String()
ch.name = who
ch.path <- "You are " + who
ch.path <- getCurConn()

messages <- who + " has arrived"
entering <- ch

input := bufio.NewScanner(conn)
for input.Scan() {
	messages <- who + ": " + input.Text()
	ch.alive <- struct{}{}
}
// NOTE: ignoring potential errors from input.Err()

leaving <- ch
messages <- who + " has left"
conn.Close()

}

func clientWriter(conn net.Conn, ch* client) {
for msg := range ch.path {
fmt.Fprintln(conn, msg) // NOTE: ignoring network errors
}
}

//!-handleConn

//!+main
func main() {
listener, err := net.Listen("tcp", "localhost:8000")
if err != nil {
log.Fatal(err)
}
go broadcaster()
for {
conn, err := listener.Accept()
if err != nil {
log.Print(err)
continue
}
go handleConn(conn)
}
}

[xubai-owo]

8.12 + 8.13

package main

import (
	"bufio"
	"fmt"
	"log"
	"net"
	"time"
)

type Client struct {
	Name string
	Ch   chan<- string
}

var (
	entering = make(chan Client)
	leaving  = make(chan chan<- string)
	messages = make(chan string)
)

func broadcaster() {
	clients := make(map[chan<- string]string)
	for {
		select {
		case msg := <-messages:
			for cli := range clients {
				cli <- msg
			}
		case cli := <-entering:
			clients[cli.Ch] = cli.Name
			for ch, name := range clients {
				if ch != cli.Ch {
					cli.Ch <- name + " is online"
				}
			}
		case ch := <-leaving:
			_, ok := clients[ch]
			if ok {
				delete(clients, ch)
				close(ch)
			}
		}
	}
}

func handleConn(conn net.Conn) {
	ch := make(chan string)
	go clientWriter(conn, ch)

	who := conn.RemoteAddr().String()
	ch <- "You are " + who
	messages <- who + " has arrived"
	entering <- Client{Name: who, Ch: ch}

	input := bufio.NewScanner(conn)
	timer := time.NewTimer(5 * time.Minute)
	defer timer.Stop()

	done := make(chan struct{})

	go func() {
		select {
		case <-timer.C:
			conn.Close()
		case <-done:
			return
		}
	}()

	for input.Scan() {
		if !timer.Stop() {
			<-timer.C
			break
		}
		timer.Reset(5 * time.Minute)
		messages <- who + ": " + input.Text()
	}

	close(done)

	leaving <- ch
	messages <- who + " has left"
	conn.Close()
}

func clientWriter(conn net.Conn, ch <-chan string) {
	for msg := range ch {
		fmt.Fprintln(conn, msg)
	}
}

func main() {
	listener, err := net.Listen("tcp", "localhost:8000")
	if err != nil {
		log.Fatal(err, "is me")
	}
	go broadcaster()

	for {
		conn, err := listener.Accept()
		if err != nil {
			log.Print(err, "连接断开")
			continue
		}
		go handleConn(conn)
	}
}