Cara melaksanakan rangka kerja pengaturcaraan rangkaian konkurensi tinggi dalam bahasa Go

Dalam merealisasikan pengaturcaraan rangkaian konkurensi tinggi, rangka kerja Workerman bahasa PHP sentiasa terkenal dengan prestasi cemerlang dan kesederhanaan serta kemudahan penggunaan. Walau bagaimanapun, berbanding dengan bahasa PHP, Golang lebih sesuai untuk pembangunan sistem berkonkurensi tinggi dan teragih, jadi melaksanakan rangka kerja pekerja versi Golang telah menjadi usaha ramai pembangun. Dalam artikel ini, kami akan memperkenalkan cara menggunakan bahasa Golang untuk melaksanakan rangka kerja pengaturcaraan rangkaian serentak tinggi, serupa dengan Workerman.

1. Pengetahuan prasyarat

Sebelum kita mula, kita perlu menguasai beberapa pengetahuan asas:

1. Asas bahasa Golang: pembolehubah, fungsi, struktur, antara muka, dll. konsep.

2. Asas pengaturcaraan rangkaian: pengetahuan asas TCP/UDP, HTTP dan protokol lain.

3.Goroutine: Coroutine bahasa Golang boleh meningkatkan kecekapan pengaturcaraan serentak.

4.Saluran: Mekanisme komunikasi yang disediakan oleh bahasa Golang, yang boleh digunakan untuk penghantaran data dan penyegerakan antara coroutine yang berbeza.

5.Pilih: Mekanisme pemultipleksan yang disediakan oleh bahasa Golang, yang boleh memantau status berbilang Saluran dan meningkatkan kecekapan program.

2. Seni bina Rangka Kerja

Menurut pelaksanaan rangka kerja pekerja, kami boleh membahagikannya kepada tiga bahagian:

1.

2. Proses perniagaan digunakan untuk mengendalikan permintaan pelanggan.

3. Pantau status sambungan pelanggan dan kitar semula.

Dalam bahasa Golang, kita boleh menggunakan goroutine untuk melaksanakan ketiga-tiga bahagian di atas masing-masing.

1. Terima sambungan dan jana klien

Kita boleh menggunakan pakej "net" yang disertakan dengan bahasa Golang untuk mencipta pelayan TCP, dan pada masa yang sama membuka goroutine untuk memantau status sambungan pelanggan.

import (
  "fmt"
  "net"
)

func main() {
  listener, err := net.Listen("tcp", "127.0.0.1:8080")
  if err != nil {
    fmt.Println("failed to listen:", err)
    return
  }

  go func() {
    for {
      conn, err := listener.Accept()
      if err != nil {
        fmt.Println("failed to accept:", err)
        continue
      }
      // 生成客户端
    }
  }()

  // 等待进程退出
  select {}
}

Selepas menerima sambungan pelanggan, kami perlu merangkum objek Pelanggan untuk mengendalikan semua permintaan dan respons untuk sambungan.

type Client struct {
  Conn   net.Conn
  RespCh chan []byte
}

func NewClient(conn net.Conn) *Client {
  return &Client {
    Conn:   conn,
    RespCh: make(chan []byte, 10),
  }
}

2. Proses perniagaan yang digunakan untuk memproses permintaan pelanggan

Permintaan dan respons pelanggan dihantar terus melalui Saluran. Apabila sambungan baharu diterima, kami perlu memasukkannya ke dalam objek Klien dan membuka goroutine untuk mengendalikan sambungan. Goroutine ini akan mendengar semua permintaan yang dihantar oleh pelanggan melalui Saluran dan bertindak balas dengan sewajarnya.

Kami merangkum proses perniagaan ke dalam antara muka Pengendali.

type Handler interface {
  OnConnect(*Client) error
  OnMessage(*Client, []byte) error
  OnClose(*Client) error
}

Permintaan dan respons pelanggan dihantar melalui atribut RespCh objek Pelanggan. Oleh itu, dalam antara muka Pengendali, kita perlu menentukan sifat RespCh untuk menerima respons daripada pelanggan.

type Handler interface {
  OnConnect(*Client) error
  OnMessage(*Client, []byte) error
  OnClose(*Client) error
  RespCh() chan []byte
}

Kami boleh mencipta EchoHandler untuk melaksanakan antara muka Pengendali.

type EchoHandler struct {
  clients   []*Client
  respChan  chan []byte
}

func NewEchoHandler() *EchoHandler {
  return &EchoHandler{
    clients:  make([]*Client, 0),
    respChan: make(chan []byte, 10),
  }
}

func (h *EchoHandler) OnConnect(c *Client) error {
  h.clients = append(h.clients, c)
  return nil
}

func (h *EchoHandler) OnMessage(c *Client, data []byte) error {
  // 将客户端发送的数据广播给所有其他客户端，并将其存入respChan中
  for _, client := range h.clients {
    if client == c {
      continue
    }
    client.RespCh <- data
  }
  return nil
}

func (h *EchoHandler) OnClose(c *Client) error {
  for index, client := range h.clients {
    if client == c {
      h.clients = append(h.clients[:index], h.clients[index+1:]...)
    }
  }
  return nil
}

func (h *EchoHandler) RespCh() chan []byte {
  return h.respChan
}

Selepas objek Pelanggan setiap pelanggan yang disambungkan disimpan dalam tatasusunan pelanggan, kami boleh menerima data yang dihantar oleh setiap pelanggan melalui atribut RespCh untuk menyiarkan maklumat yang dihantar oleh pelanggan lain .

3. Pantau status sambungan pelanggan dan kitar semula

Untuk versi lama rangka kerja Workerman, Workerman akan mengitar semula sambungan terbiar dalam tempoh masa tertentu. Versi baharu Workerman melaksanakan fungsi ini melalui TCP keepalive.

Apabila melaksanakan versi Golang workerman, kami juga boleh menyelesaikan masalah sambungan terbiar melalui TCP keepalive. Kita boleh memantau status soketnya dalam goroutine setiap pelanggan Jika pelanggan tidak menghantar data selepas 10 saat masa melahu, ia akan dianggap sebagai sambungan yang tidak sah dan soketnya akan ditutup.

func (c *Client) Process() {
  defer func() {
    c.Conn.Close()
    c.handler.OnClose(c)
  }()
  // 设置 socket keepalive
  tcpConn, ok := c.Conn.(*net.TCPConn)
  if ok {
    tcpConn.SetKeepAlive(true)
    tcpConn.SetKeepAlivePeriod(10 * time.Second)
  }
  // 进入读协程，接收客户端发送的所有数据
  go func() {
    for {
      buf := make([]byte, 1024)
      n, err := c.Conn.Read(buf)
      if err != nil {
        if err != io.EOF {
          fmt.Println("failed to read:", err)
        }
        break
      }
      // 将客户端发送的消息交给Handler处理
      c.handler.OnMessage(c, buf[:n])
    }
  }()
  // 进入写协程，将respChan中的所有响应发送给当前客户端
  go func() {
    for resp := range c.handler.RespCh() {
      _, err := c.Conn.Write(resp)
      if err != nil {
        fmt.Println("failed to write:", err)
        break
      }
    }
  }()
  // OnConnect
  err := c.handler.OnConnect(c)
  if err != nil {
    fmt.Println("failed to on connect:", err)
    return
  }
  // 在Worker进程退出时进行清理
  select {}
}

3. Laksanakan proses Pekerja

Selepas menyelesaikan tiga langkah di atas, kami perlu mencipta proses Pekerja untuk menguruskan semua sambungan pelanggan. Satu atau lebih Pengendali perlu dimuatkan dalam proses Pekerja untuk mengendalikan semua permintaan data yang dihantar oleh pelanggan.

type Worker struct {
  listener  net.Listener
  handlers  map[string]Handler
}

func NewWorker(addr string) (*Worker, error) {
  listener, err := net.Listen("tcp", addr)
  if err != nil {
    fmt.Println("failed to listen:", err)
    return nil, err
  }
  return &Worker{
    listener: listener,
    handlers: make(map[string]Handler),
  }, nil
}

func (w *Worker) Register(name string, handler Handler) {
  w.handlers[name] = handler
}

func (w *Worker) Start() {
  go func() {
    for {
      conn, err := w.listener.Accept()
      if err != nil {
        fmt.Println("failed to accept:", err)
        continue
      }
      // 封装连接客户端为Client对象，用于后续的处理
      client := NewClient(conn)
      client.handler = w.handlers["Echo"]
      // 开启客户端goroutine来处理该连接
      go client.Process()
    }
  }()
  // 等待进程退出
  select {}
}

Dalam proses Worker, kita perlu menentukan atribut pengendali untuk menyimpan contoh Pengendali yang berbeza, dan memantau sambungan klien dalam fungsi Start() dan membuka goroutine baharu untuk mengendalikan permintaan pelanggan .

4. Ujian

Kami boleh menggunakan kod berikut untuk mencipta proses Pekerja dan mendaftarkan EchoHandler di dalamnya untuk mengendalikan semua permintaan pelanggan.

func main() {
  server, _ := NewWorker("127.0.0.1:8080")
  handler := NewEchoHandler()
  server.Register("Echo", handler)
  server.Start()
}

Kami boleh menggunakan alat telnet untuk mensimulasikan berbilang pelanggan menghantar mesej ke pelayan dan melihat penerimaan mereka.

Kami menggunakan arahan berikut untuk menyambung ke pelayan:

telnet 127.0.0.1 8080

Kami boleh memasukkan teks berikut dalam telnet:

Hello workerman!

Kami boleh membuka berbilang tetingkap telnet pada masa yang sama, untuk mensimulasikan berbilang permintaan selari pelanggan.

Pada pelayan, kita dapat melihat output:

$ go run worker.go 
服务器已启动...
failed to read: read tcp 127.0.0.1:8080->127.0.0.1:56182: use of closed network connection

Ini kerana apabila kita menutup sambungan klien, ia membatalkan operasi mendengarnya, mengakibatkan ralat baca.

Selepas input telnet selesai, kita dapat melihat bahawa setiap tetingkap telnet akan menerima teks yang dikembalikan oleh pelayan.

5. Ringkasan

Dalam artikel ini, kami memperkenalkan cara menggunakan bahasa Golang untuk melaksanakan rangka kerja pengaturcaraan rangkaian konkurensi tinggi, serupa dengan workerman dalam bahasa PHP. Semasa proses pelaksanaan, kami menggunakan coroutine, mekanisme komunikasi dan mekanisme pemultipleksan dalam bahasa Golang, dan berjaya melaksanakan rangka kerja pengaturcaraan rangkaian konkurensi tinggi yang serupa dengan Workerman dengan merangkum objek Pelanggan dan antara muka Pengendali.

Malah, dalam pengaturcaraan harian, kami mengesyorkan terus menggunakan pakej net/http yang disediakan oleh bahasa Golang untuk melaksanakan pengaturcaraan rangkaian konkurensi tinggi, yang lebih ringkas dan mempunyai prestasi yang lebih baik daripada rangka kerja pekerja. Kami hanya perlu membuka pelayan http dan menggunakan goroutine untuk memproses setiap permintaan secara serentak untuk melaksanakan pengaturcaraan rangkaian konkurensi tinggi dengan mudah.

Atas ialah kandungan terperinci Cara melaksanakan rangka kerja pengaturcaraan rangkaian konkurensi tinggi dalam bahasa Go. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!