想把流量发个多个后端,每个后端都可以收到内容,但我写的,每次都只有一个后端收到内容,随机的
```
package main
import (
"flag"
"fmt"
"io"
"net"
"strings"
)
var tcp_conn []net.Conn
func main() {
var address *string
var dst *string
address = flag.String("listen_address", "127.0.0.1:8080", "listen address")
dst = flag.String("target_address", "172.16.5.9:18061,172.16.5.9:18060", "目标地址,多个地址逗号分割")
flag.Parse()
listener, err := net.Listen("tcp", *address)
if err != nil {
fmt.Println(err)
}
ips := strings.Split(*dst, ",")
if len(ips) == 0 {
fmt.Println("目标地址不能为空")
return
}
for _, ip := range ips {
conn, err := net.Dial("tcp", ip)
if err != nil {
fmt.Println(err)
continue
}
tcp_conn = append(tcp_conn, conn)
}
for {
conn, err := listener.Accept()
if err != nil {
continue
}
go handler(conn)
}
}
func handler(conn net.Conn) {
// defer conn.Close()
for _, dst_conn := range tcp_conn {
go io.Copy(dst_conn, conn)
go io.Copy(conn, dst_conn)
}
}
```
该如何改呢,哪位大佬帮忙看看
请问如果实现轮询发送的话应该怎么做呢?就是第一次发给服务器A,接收它的返回;第二次发给服务器B,接收它的返回,以此类推,基于您的基础上改了改发现有问题
```go
func (p *pipeline) serve() {
defer p.close()
//master := p.backs[0]
//go p.readFrom(master)
//
//discards := p.backs[1:]
//if len(discards) != 0 {
// go p.discard(discards)
//}
buf := make([]byte, 1024)
bufRead := make([]byte, 1024)
index := 0
for {
n, err := p.conn.Read(buf)
if err != nil {
return
}
if _, err := p.backs[index].Write(buf[:n]); err != nil {
break
}
fmt.Println("index: ", index)
n, err = p.backs[index].Read(bufRead)
if err != nil {
break
}
if _, err = p.conn.Write(bufRead[:n]); err != nil {
break
}
index = (index + 1) % len(p.backs)
}
}
```
#11
更多评论
某个协程io.Copy之后相当于读完了流,另外的协程当然读不到数据了,你需要修改代码,每次读取[]byte,然后再每个连接Write([]byte)
#1