Go项目实战:01-聊天室+map竞争需要上锁

飞哥前程似锦

已于 2022-12-15 21:04:13 修改

阅读量352

点赞数

分类专栏： Golang 文章标签： golang 网络服务器

于 2022-12-15 10:31:06 首次发布

本文链接：https://blog.csdn.net/tianyi520jx/article/details/127508330

版权

Golang 专栏收录该内容

49 篇文章 10 订阅

订阅专栏

实现一个聊天室（群）：

功能分析：

1、上线下线
2、聊天：其他人和自己都可以看到聊天消息
3、查询当前的聊天室用户所有人的名字
4、可以修改自己的名字
5、超时潜水踢出机制

技术点分析：

1、socket tcp编程
2、map结构，存储所有的用户
- 1、存储所有的用户
- 2、map遍历
- 3、map删除
3、go 程、channel
4、select （超时退出、主动退出）
5、timer 定时器

效果展示

请添加图片描述

具体实现

1、tcp socket，建立多个连接

package main

import (
	"fmt"
	"net"
)

//课程将所有代码写在一个文件中，没有做代码整理了
func main() {
	//创建服务器
	listener, err := net.Listen("tcp", ":8080")
	if err != nil {
		fmt.Println("net.Listen err:", err)
		return
	}
	fmt.Println("服务器启动成功，监听中...")

	for {
		fmt.Println("====>主go程监听中...")
		//监听
		conn, err := listener.Accept()
		if err != nil {
			fmt.Println("listener.Accept err:", err)
			return
		}
		//建立连接
		fmt.Println("建立连接成功")

		//启动处理业务的go程
		go handler(conn)
	}

}

func handler(conn net.Conn) {
	for {
		fmt.Println("启动业务...")
		//TODO  //代表这里以后再具体实现，当前保留
		buf := make([]byte, 1024)

		//读取客户端发送过来的请求数据
		cnt, err := conn.Read(buf)
		if err != nil{
			fmt.Println("conn.Read err:", err)
			return
		}

		fmt.Println("客户端发送过来的数据为：", string(buf[:cnt-1]), ",cnt:", cnt)
	}
}

2、思路分析

思路分析图

请添加图片描述

数据流分析

请添加图片描述

3、定义User/map结构

type User struct {
	//名字
	name string
	//唯一的id
	id string
	//管道
	msg chan string
}

//创建一个全局的map结构，用户保存所有的用户
var allUsers = make(map[string]User)

在handler中调用

请添加图片描述

4、定义message通道

请添加图片描述

创建监听广播go程函数
请添加图片描述

启动：读全局唯一
请添加图片描述

写入上线数据
请添加图片描述

bug修复
请添加图片描述
效果：

5、user监听通道go程

每个用户应该还有一个用来监听自己msg管道的go程，负责将数据返回给客户端

func writeBackToClient(user *User, conn net.Conn){
	//TODO
	fmt.Printf("user : %s 的go程正在监听自己的msg管道：\n", user.name)
	for data := range user.msg{
		fmt.Printf("user: %s写回给客户端的数据为：%s \n", user.name, data)
		//Write(b []byte) (n int,err error)
		_, _ = conn.Write([]byte(data))
	}
}

请添加图片描述

代码

package main

import (
	"fmt"
	"net"
)

//课程将所有代码写在一个文件中，没有做代码整理了

type User struct {
	//名字
	name string
	//唯一的id
	id string
	//管道
	msg chan string
}

//创建一个全局的map结构，用户保存所有的用户
var allUsers = make(map[string]User)
//定义一个message全局通道，用于接收任何人发送过来的消息
var message = make(chan string, 10)

func main() {
	//创建服务器
	listener, err := net.Listen("tcp", ":8080")
	if err != nil {
		fmt.Println("net.Listen err:", err)
		return
	}
	//启动全局唯一的go程，负责监听message通道，写给所有的用户
	go broadcast()

	fmt.Println("服务器启动成功，监听中...")

	for {
		fmt.Println("====>主go程监听中...")
		//监听
		conn, err := listener.Accept()
		if err != nil {
			fmt.Println("listener.Accept err:", err)
			return
		}
		//建立连接
		fmt.Println("建立连接成功")

		//启动处理业务的go程
		go handler(conn)
	}

}

func handler(conn net.Conn) {

		fmt.Println("启动业务...")

		clientAddr := conn.RemoteAddr().String()
		fmt.Println("clientAddr:",clientAddr)
		//创建user
		newUser := User{
			id: clientAddr, //id,我们不会修改。这个作为map中的key
			name: clientAddr,//可以修改，会提供rename命令修改，建立连接时，初始值与id相同
			msg: make(chan string, 10),//注意需要make空间，否则无法导入数据
		}
		//添加user到map结构
		allUsers[newUser.id] = newUser

		//启动go程，负责将msg心息返回给客户端
		go writeBackToClient(&newUser, conn)

		//向message写入数据。当前用户上线的消息，用于通知所有人（广播）
		loginInfo:= fmt.Sprintf("[%s]:[%s] ===> 上线了login！", newUser.id, newUser.name)//字符串拼接
		message <- loginInfo

		for {
		//具体业务逻辑
		buf := make([]byte, 1024)

		//读取客户端发送过来的请求数据
		cnt, err := conn.Read(buf)
		if err != nil{
			fmt.Println("conn.Read err:", err)
			return
		}

		fmt.Println("服务器接收客户端发送过来的数据为：", string(buf[:cnt-1]), ",cnt:", cnt)
	}
}

//向所有用户广播消息，启动一个全局唯一的go程
func broadcast() {
	 fmt.Println("广播go程启动成功...")
	 defer fmt.Println("broadcast程序退出！")

	 for{
	 	 //1、从message中读取数据
		 fmt.Println("broadcast监听message中...")
		 info := <- message
		 //2、将数据写入到每一个用户的msg管道中
		 for _, user := range allUsers{
			 //如果msg是非缓冲的，将会在这里阻塞
			 user.msg <- info
		 }
	 }
}
//每个用户应该还有一个用来监听自己msg管道的go程，负责将数据返回给客户端
func writeBackToClient(user *User, conn net.Conn){
	//TODO
	fmt.Printf("user : %s 的go程正在监听自己的msg管道：\n", user.name)
	for data := range user.msg{
		fmt.Printf("user: %s写回给客户端的数据为：%s \n", user.name, data)
		//Write(b []byte) (n int,err error)
		_, _ = conn.Write([]byte(data))
	}
}

增加功能

1、查询用户

查询命令：who ==》将当前所有的登录的用户，展示出来，id、name、返回给当前用户
在handler中，处理业务逻辑：

fmt.Println("服务器接收客户端发送过来的数据为：", string(buf[:cnt-1]), ",cnt:", cnt)

			//----业务逻辑处理   开始 -------
			//1、查询当前所有的用户 who
			//	a、先判断接收的数据是不是who ==》长度&&字符串
			userInput := string(buf[:cnt-1]) // 这是用户输入的数据，最后一个是回车，我们去掉它
			if len(userInput) == 3 && userInput == "who" {
				//	b、遍历allUsers这个map ：key ：= user   id value：user本身，将id和name拼接程一个字符串，返回给客户端
				fmt.Println("用户即将查询所有用户信息！")

				//这个切片包含所有的用户信息
				var userInfotable []string
				//[]string{"userid:z3, username:z3","userid:l4,username:l4","userid:w5,username:w5"}
				for _, user := range allUsers {
					userInfo := fmt.Sprintf("userid:%s,username:%s", user.id, user.name)
					userInfotable = append(userInfotable, userInfo)
				}

				//最终写道管道中，一定是一个字符串，现在相当于是n个字符串
				r := strings.Join(userInfotable,"\n")//链接数组切片，生成字符串
				//strings.Split()  分割字符串
				//`
				// "userid:z3, username:z3",
				// "userid:l4,username:l4",
				// "userid:w5,username:w5"
				//`
				newUser.msg <- r

			}else{
				//如果用户输入的不是命令知识不普通的聊天信息，则只需要写到广播通道即可，由其他的go程进行处理，进行常规转发
				message <- userInput
			}

效果：请添加图片描述

2、重命名

规则： rename｜Duke

1、读取数据判断长度是否>8，并且判断字符是否为rename
2、使用｜进行分割，获取｜后面的部分，作为名字
3、update 用户名字 newUser = Duike
4、通知客户端，更新成功

else if len(userInput) > 9 && userInput[:7] == "\\rename" {
				//[:3] //0, 1, 2 ==> 左闭右开


				//规则: rename|Duke
				//- 1、读取数据判断长度是否>8，并且判断字符是否为rename

			    //- 2、使用｜进行分割，获取｜后面的部分，作为名字

				//arry := strings.Split(userInput,"|")
			    //name := array[1]

				//- 3、update 用户名字 newUser = Duke
				newUser.name = strings.Split(userInput,"|")[1]
				allUsers[newUser.id] = newUser //更新为map中的user
			    //- 4、通知客户端，更新成功
				newUser.msg <- "rename successfuly!"

			}

效果：
请添加图片描述

3、主动退出

quit && contro + c

用户退出：清理工作
1、从map中删除
2、对应的conn要close

每个用户都有自己的watch go程，负责监听退出信号

//启动一个go程只负责用来监听退出信号isQuit，触发后，进行清零工作：delete map，close conn
func watch(user *User, conn net.Conn, isQuit <-chan bool) {
	fmt.Println("2222启动监听退出信号的go程")
	defer fmt.Println("watch go程退出！")
	for {
		select {
		case <- isQuit:
			logoutInfo := fmt.Sprintf("%s exit already", user.name)
			fmt.Println("删除当前用户",user.name)
			delete(allUsers, user.id)
			message <-logoutInfo
			conn.Close()
			return
		}
	}
}

在handle中启动go watch ，同时传入相应信息：

		//启动go程负责监听退出信号
		go watch(&newUser, conn, isQuit)

请添加图片描述

在read之后，通过读取的cnt判断用户退出，向isQuit中写入信号：
请添加图片描述

测试结果：
请添加图片描述

4、超时退出

使用定时器来进行超时管理

如果60秒内没有发送任何数据，那么直接将这个连接关闭：

<- time.After(60 *time.second) //chan time

func watch(user *User, conn net.Conn, isQuit, restTimer <- chan bool) {
	//func watch(user *User, conn net.Conn, isQuit <- chan bool, restTimer <- chan bool)   |   i, j int
	fmt.Println("2222启动监听退出信号的go程")
	defer fmt.Println("watch go程退出！")
	for {
		select {
		case <- isQuit:
			logoutInfo := fmt.Sprintf("%s exit already\n", user.name)
			fmt.Println("删除当前用户",user.name)
			delete(allUsers, user.id)
			message <-logoutInfo//消息告诉所有人

			conn.Close()
			return
		case <- time.After(10 *  time.Second):
			logoutInfo := fmt.Sprintf("%s timeout exit already\n", user.name)
			fmt.Println("删除当前用户",user.name)
			delete(allUsers, user.id)
			message <-logoutInfo//消息告诉所有人

			conn.Close()
			return
		case <- restTimer:
			fmt.Sprintf("连接%s，重置计数器\n", user.name)
		}
	}
}

创建并传入restTimer管道
请添加图片描述

效果：

map需要上锁

package main

import (
	"fmt"
	"sync"
	"time"
)

var idnames sync.Map
var lock sync.RWMutex

//map不允许同时读写，如果有不同go程同时操作map， 需要对map上锁
//concurrent map read and map write
func main() {
	go func() {
		for {
			//lock.Lock()
			fmt.Println("111111")
			idnames.Store("duke",0)
			fmt.Println("222222")
			//lock.Unlock()
		}
	}()
	go func() {
		for {
			//lock.Lock()
			fmt.Println("aaaaaa")
			name, _ := idnames.Load("duke")
			fmt.Println("name:", name)
			fmt.Println("bbbbbb")
			//lock.Unlock()
		}
	}()

	for {
		fmt.Println("OVER")
		time.Sleep(1 * time.Second)
	}
}

飞哥前程似锦

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Go项目实战:01-聊天室+map竞争需要上锁

/名字 name string //唯一的id id string //管道 msg chan string } //创建一个全局的map结构，用户保存所有的用户 var allUsers = make(map [ string ] User)在handler中调用创建监听广播go程函数启动：读全局唯一写入上线数据bug修复。
复制链接

扫一扫