Golang melaksanakan siaran

Golang ialah bahasa pengaturcaraan yang cekap, iaitu bahasa yang dibangunkan oleh Google. Dalam bidang Internet moden, Golang sudah pasti merupakan bahasa pengaturcaraan yang sangat penting Prestasi cemerlangnya dan aplikasi berskala tinggi sangat sesuai untuk membina aplikasi rangkaian berskala besar dan berprestasi tinggi. Di sini kami akan memperkenalkan cara menggunakan Golang untuk melaksanakan fungsi penyiaran.

Penyiaran ialah kaedah untuk menerbitkan mesej kepada berbilang pelanggan. Dalam protokol komunikasi, siaran ialah penghantaran paket maklumat ke alamat tertentu pada rangkaian supaya paket itu ditangkap oleh semua komputer di sekitar alamat tersebut. Biasanya, siaran digunakan untuk memberitahu semua orang tentang kejadian peristiwa.

Di Golang, pelaksanaan penyiaran boleh merealisasikan fungsi penyiaran dengan menghantar data ke berbilang sambungan pada masa yang sama. Kami boleh menggunakan senarai berbilang sambungan pelanggan dan menghantar mesej kepada setiap pelanggan. Goroutine dan saluran digunakan di sini untuk melaksanakan penyiaran.

Pertama, kita perlu membuat senarai sambungan:

type Client struct {
    conn net.Conn
    name string
}

type ConnectionList struct {
    clients map[*Client]bool
    broadcast chan string
    addClient  chan *Client
    removeClient chan *Client
}

Dalam kod di atas, struktur Pelanggan menyimpan maklumat tentang menyambungkan pelanggan, dan struktur ConnectionList menyimpan senarai sambungan pelanggan, termasuk Saluran untuk menyiarkan mesej dan saluran untuk menambah dan memadam sambungan.

Berikut ialah fungsi tambah dan buang untuk sambungan:

func (list *ConnectionList) add(client *Client) {
    list.clients[client] = true
}

func (list *ConnectionList) remove(client *Client) {
    if _, ok := list.clients[client]; ok {
        delete(list.clients, client)
        close(client.conn)
    }
}

Seterusnya, kami akan mencipta lebih banyak goroutine dan saluran untuk mengendalikan sambungan dan menyiarkan mesej kepada semua pelanggan yang disambungkan:

func handleConnection(conn net.Conn, list *ConnectionList) {
    client := &Client{conn: conn}

    list.addClient <- client
    defer func() {
        list.removeClient <- client
    }()

    for {
        message := make([]byte, 4096)
        length, err := conn.Read(message)

        if err != nil || length == 0 {
            break
        }

        data := strings.TrimSpace(string(message[:length]))

        if len(data) > 0 {
            list.broadcast <- data
        }
    }
}

func (list *ConnectionList) broadcastMessage() {
    for {
        message := <-list.broadcast
        for client := range list.clients {
            _, err := client.conn.Write([]byte(message + "
"))

            if err != nil {
                list.removeClient <- client
            }
        }
    }
}

func (list *ConnectionList) handleClients() {
    for {
        select {
        case client := <-list.addClient:
            list.add(client)
        case client := <-list.removeClient:
            list.remove(client)
        case <-time.After(60 * time.Second):
            fmt.Println("Keep alive.")
        }
    }
}

fungsi handleConnection mengendalikan permintaan sambungan dan, jika wujud, ditambahkan pada senarai sambungan. Mesej siaran diproses melalui fungsi broadcastMessage. Akhirnya, fungsi handleClients berjalan selama-lamanya supaya senarai sambungan kekal aktif untuk masa yang lama.

Gabungkan kaedah bersama-sama:

func main() {
    list := &ConnectionList{
        clients: make(map[*Client]bool),
        broadcast: make(chan string),
        addClient:  make(chan *Client),
        removeClient: make(chan *Client),
    }

    go list.broadcastMessage()
    go list.handleClients()

    listen, err := net.Listen("tcp", ":6000")
    if err != nil {
        fmt.Println(err)
        return
    }

    defer listen.Close()

    for {
        conn, err := listen.Accept()
        if err != nil {
            fmt.Println(err)
            continue
        }

        go handleConnection(conn, list)
    }
}

Dalam contoh mudah ini, kita boleh menggunakan Golang untuk melaksanakan fungsi penyiaran mesej. Seperti yang anda lihat, Golang adalah cekap, boleh dipercayai dan fleksibel, menjadikannya pilihan ideal untuk membina aplikasi teragih berprestasi tinggi.

Atas ialah kandungan terperinci Golang melaksanakan siaran. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!