精易论坛

标题: 有没有go的多线程协议发包框架想学习一下 [打印本页]

作者: mjayce 时间: 2025-6-15 01:29
标题: 有没有go的多线程协议发包框架想学习一下
不知道那些库好用鱼刺和yyjson用惯了

作者: appleqc 时间: 2025-6-15 09:57
### Go语言多线程协议发包框架推荐

在Go语言中，多线程通常通过goroutine和channel实现，网络发包则依赖于标准库中的net包。以下是几个适合学习和使用的Go发包框架及库：

### 一、高性能HTTP发包框架

#### 1. **net/http** (标准库)
- **特点**：内置HTTP客户端，支持连接池、超时控制、中间件等
- **示例**：
   ```go
   package main

   import (
      "fmt"
      "io/ioutil"
      "net/http"
      "time"
   )

   func main() {
      // 创建带连接池的客户端
      client := &http.Client{
         Timeout: 10 * time.Second,
      }

      // 多goroutine并发发包
      for i := 0; i < 10; i++ {
         go func(id int) {
               req, _ := http.NewRequest("GET", "https://api.example.com", nil)
               req.Header.Set("User-Agent", "MyApp/1.0")
               resp, err := client.Do(req)
               if err != nil {
                  fmt.Printf("请求 #%d 失败: %v\n", id, err)
                  return
               }
               defer resp.Body.Close()
               body, _ := ioutil.ReadAll(resp.Body)
               fmt.Printf("请求 #%d 成功，状态码: %d\n", id, resp.StatusCode)
         }(i)
      }

      // 等待所有goroutine完成
      time.Sleep(5 * time.Second)
   }
   ```

#### 2. **fasthttp**
- **特点**：比标准库快10倍以上，适合高频发包场景
- **示例**：
   ```go
   package main

   import (
      "fmt"
      "log"
      "time"

      "github.com/valyala/fasthttp"
   )

   func main() {
      client := &fasthttp.Client{
         ReadTimeout:  5 * time.Second,
         WriteTimeout: 5 * time.Second,
      }

      // 并发发包
      for i := 0; i < 100; i++ {
         go func(id int) {
               req := fasthttp.AcquireRequest()
               resp := fasthttp.AcquireResponse()
               defer func() {
                  fasthttp.ReleaseRequest(req)
                  fasthttp.ReleaseResponse(resp)
               }()

               req.SetRequestURI("https://api.example.com")
               req.Header.SetMethod("GET")

               if err := client.Do(req, resp); err != nil {
                  log.Printf("请求 #%d 失败: %v", id, err)
                  return
               }

               fmt.Printf("请求 #%d 成功，状态码: %d\n", id, resp.StatusCode())
         }(i)
      }

      time.Sleep(5 * time.Second)
   }
   ```

### 二、通用网络协议发包框架

#### 1. **net包** (标准库)
- **特点**：支持TCP/UDP/Socket等底层协议
- **示例**：TCP发包
   ```go
   package main

   import (
      "fmt"
      "net"
      "time"
   )

   func main() {
      // 并发发送TCP包
      for i := 0; i < 5; i++ {
         go func(id int) {
               conn, err := net.DialTimeout("tcp", "example.com:80", 2*time.Second)
               if err != nil {
                  fmt.Printf("连接失败 #%d: %v\n", id, err)
                  return
               }
               defer conn.Close()

               // 发送HTTP请求
               request := "GET / HTTP/1.1\r\nHost: example.com\r\n\r\n"
               conn.Write([]byte(request))

               // 接收响应
               buffer := make([]byte, 1024)
               n, _ := conn.Read(buffer)
               fmt.Printf("请求 #%d 收到响应: %s\n", id, buffer[:n])
         }(i)
      }

      time.Sleep(3 * time.Second)
   }
   ```

#### 2. **gRPC**
- **特点**：高性能、开源的远程过程调用(RPC)框架
- **示例**：
   ```go
   // 定义proto文件
   syntax = "proto3";
   package helloworld;

   service Greeter {
   rpc SayHello (HelloRequest) returns (HelloReply) {}
   }

   message HelloRequest {
   string name = 1;
   }

   message HelloReply {
   string message = 1;
   }

   // 客户端代码
   func main() {
      conn, err := grpc.Dial("server:50051", grpc.WithInsecure())
      if err != nil {
         log.Fatalf("连接失败: %v", err)
      }
      defer conn.Close()

      client := pb.NewGreeterClient(conn)
      ctx, cancel := context.WithTimeout(context.Background(), time.Second)
      defer cancel()

      // 并发调用
      for i := 0; i < 10; i++ {
         go func(id int) {
               resp, err := client.SayHello(ctx, &pb.HelloRequest{Name: fmt.Sprintf("User%d", id)})
               if err != nil {
                  log.Printf("调用失败 #%d: %v", id, err)
                  return
               }
               fmt.Printf("响应 #%d: %s\n", id, resp.Message)
         }(i)
      }

      time.Sleep(2 * time.Second)
   }
   ```

### 三、JSON处理库推荐

#### 1. **json-iterator/go** (替代yyjson)
- **特点**：比标准库快3倍以上，支持零拷贝解析
- **示例**：
   ```go
   package main

   import (
      "fmt"
      jsoniter "github.com/json-iterator/go"
   )

   func main() {
      type Person struct {
         Name string `json:"name"`
         Age  int `json:"age"`
      }

      // 解析JSON
      data := []byte(`{"name":"John","age":30}`)
      var p Person
      jsoniter.Unmarshal(data, &p)
      fmt.Printf("姓名: %s, 年龄: %d\n", p.Name, p.Age)

      // 生成JSON
      result, _ := jsoniter.Marshal(p)
      fmt.Println(string(result))
   }
   ```

#### 2. **go-faster/yaml** (替代鱼刺)
- **特点**：高性能YAML解析器，兼容标准库
- **示例**：
   ```go
   package main

   import (
      "fmt"
      "github.com/go-faster/yaml"
   )

   func main() {
      type Config struct {
         Server struct {
               Host string `yaml:"host"`
               Port int `yaml:"port"`
         } `yaml:"server"`
         LogLevel string `yaml:"log_level"`
      }

      data := []byte(`
      server:
         host: localhost
         port: 8080
      log_level: debug
      `)

      var cfg Config
      yaml.Unmarshal(data, &cfg)
      fmt.Printf("服务器: %s:%d\n日志级别: %s\n",
                  cfg.Server.Host, cfg.Server.Port, cfg.LogLevel)
   }
   ```

### 四、多线程控制与并发模式

#### 1. **Worker Pool模式**
```go
package main

import (
   "fmt"
   "sync"
)

func main() {
   jobs := make(chan int, 100)
   results := make(chan string, 100)

   // 启动3个worker goroutine
   var wg sync.WaitGroup
   for w := 1; w <= 3; w++ {
         wg.Add(1)
         go worker(w, jobs, results, &wg)
   }

   // 发送5个任务
   go func() {
         for j := 1; j <= 5; j++ {
            jobs <- j
         }
         close(jobs)
   }()

   // 收集结果
   go func() {
         wg.Wait()
         close(results)
   }()

   // 输出结果
   for res := range results {
         fmt.Println(res)
   }
}

func worker(id int, jobs <-chan int, results chan<- string, wg *sync.WaitGroup) {
   defer wg.Done()
   for j := range jobs {
         results <- fmt.Sprintf("Worker %d 完成任务 %d", id, j)
   }
}
```

#### 2. **并发控制与限流**
```go
import (
   "golang.org/x/time/rate"
   "sync"
)

func main() {
   // 创建一个限速器，每秒允许2个请求
   limiter := rate.NewLimiter(rate.Limit(2), 1) // 令牌桶容量为1

   var wg sync.WaitGroup
   for i := 0; i < 10; i++ {
         wg.Add(1)
         go func(id int) {
            defer wg.Done()

            // 等待令牌
            if err := limiter.Wait(context.Background()); err != nil {
               return
            }

            // 执行受限操作
            fmt.Printf("执行请求 #%d\n", id)
         }(i)
   }

   wg.Wait()
}
```

### 五、学习资源推荐

1. **官方文档**：
- Go标准库文档：https://pkg.go.dev/
- fasthttp文档：https://github.com/valyala/fasthttp
- gRPC文档：https://grpc.io/docs/languages/go/

2. **推荐书籍**：
- 《Go语言实战》
- 《Go语言高级编程》

3. **实战项目**：
- 实现一个简单的HTTP压力测试工具
- 开发一个基于gRPC的微服务
- 编写一个多协程爬虫程序

建议先从标准库的net/http和goroutine开始学习，掌握基础后再尝试高性能框架。JSON处理推荐使用json-iterator/go，它的API与标准库兼容且性能更优。

作者: mjayce 时间: 2025-6-16 01:32
有偿也可以

作者: 小渣渣哦 时间: 2025-6-16 01:50
http 使用req，ants协程池，

作者: ssxpvicp 时间: 2025-6-25 10:13
我想要.go的代理池就算鱼刺的代理池.多线程直接ants,,代理池github却没有.

欢迎光临精易论坛 (https://125.confly.eu.org/)