Golang如何在不覆盖现有值的情况下通过客户端请求填充Map

在你的代码中，每次处理请求时都会创建一个新的映射，这就是为什么之前的请求会被"覆盖"的原因。实际上，你并没有覆盖之前的请求，而是每次都在创建一个全新的空映射。

要解决这个问题，你需要将映射移到函数外部，使其成为持久化的存储。以下是修改后的代码：

package main

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

func check(err error, message string) {
	if err != nil {
		panic(err)
	}
	fmt.Printf("%s\n", message)
}

type ClientJob struct {
	name string
	conn net.Conn
}

// 创建全局映射和互斥锁来保证并发安全
var (
	allRequests = make(map[string]int) // 使用string作为键，int作为值（可以是请求计数）
	mu          sync.RWMutex           // 读写锁
	requestID   int                    // 用于生成唯一键
)

func generateResponses(clientJobs chan ClientJob) {
	for {
		clientJob := <-clientJobs

		for start := time.Now(); time.Now().Sub(start) < time.Second; {
		}

		clientJob.conn.Write([]byte("Hello, " + clientJob.name))

		// 使用互斥锁保护对映射的并发访问
		mu.Lock()
		requestID++
		key := fmt.Sprintf("request_%d", requestID)
		allRequests[key] = requestID
		mu.Unlock()

		// 读取时也需要加锁
		mu.RLock()
		fmt.Println("All requests in the map:", allRequests)
		mu.RUnlock()
	}
}

func main() {
	clientJobs := make(chan ClientJob)
	go generateResponses(clientJobs)

	ln, err := net.Listen("tcp", ":8080")
	check(err, "Server is ready.")

	for {
		conn, err := ln.Accept()
		check(err, "Accepted connection.")

		go func() {
			buf := bufio.NewReader(conn)

			for {
				name, err := buf.ReadString('\n')

				if err != nil {
					fmt.Printf("Client disconnected.\n")
					break
				}

				clientJobs <- ClientJob{name, conn}
			}
		}()
	}
}

如果你想要存储客户端名称而不是简单的计数，可以这样修改映射：

var (
	allRequests = make(map[int]string) // 使用int作为键，string作为值存储客户端名称
	mu          sync.RWMutex
	requestID   int
)

func generateResponses(clientJobs chan ClientJob) {
	for {
		clientJob := <-clientJobs

		for start := time.Now(); time.Now().Sub(start) < time.Second; {
		}

		clientJob.conn.Write([]byte("Hello, " + clientJob.name))

		mu.Lock()
		requestID++
		allRequests[requestID] = clientJob.name
		mu.Unlock()

		mu.RLock()
		fmt.Println("All client requests in the map:")
		for id, name := range allRequests {
			fmt.Printf("  Request %d: %s", id, name)
		}
		mu.RUnlock()
	}
}

或者如果你想要使用客户端名称作为键，并存储连接时间等信息：

type RequestInfo struct {
	Name      string
	Timestamp time.Time
	Conn      net.Conn
}

var (
	allRequests = make(map[string]RequestInfo) // 使用客户端名称作为键
	mu          sync.RWMutex
)

func generateResponses(clientJobs chan ClientJob) {
	for {
		clientJob := <-clientJobs

		for start := time.Now(); time.Now().Sub(start) < time.Second; {
		}

		clientJob.conn.Write([]byte("Hello, " + clientJob.name))

		mu.Lock()
		// 如果客户端名称可能重复，可以添加时间戳或其他唯一标识
		key := clientJob.name + "_" + time.Now().Format("20060102150405.000")
		allRequests[key] = RequestInfo{
			Name:      clientJob.name,
			Timestamp: time.Now(),
			Conn:      clientJob.conn,
		}
		mu.Unlock()

		mu.RLock()
		fmt.Printf("Total requests in map: %d\n", len(allRequests))
		for key, info := range allRequests {
			fmt.Printf("  Key: %s, Name: %s, Time: %v\n", key, info.Name, info.Timestamp)
		}
		mu.RUnlock()
	}
}

关键点是：

1. 将映射声明为全局变量（或在适当的作用域内）
2. 使用 sync.RWMutex 来保证并发安全
3. 确保每个请求都有唯一的键，这样就不会覆盖之前的条目