Rumah > pembangunan bahagian belakang > Golang > Bagaimana untuk Melaksanakan Penyiaran Pelayan-ke-Pelanggan gRPC dengan Tinjauan Panjang?

Bagaimana untuk Melaksanakan Penyiaran Pelayan-ke-Pelanggan gRPC dengan Tinjauan Panjang?

Mary-Kate Olsen
Lepaskan: 2024-11-01 20:06:02
asal
832 orang telah melayarinya

How to Implement gRPC Server-to-Client Broadcasting with Long-Polling?

Penyiaran Pelayan-ke-Pelanggan gRPC

Dalam gRPC, cabaran biasa timbul apabila menyiarkan acara daripada pelayan kepada berbilang pelanggan yang disambungkan. Soalan yang dikemukakan mencari panduan tentang cara mencapai perkara ini menggunakan strim, terutamanya dengan pelayan mengetahui siapa yang disambungkan dan cara menangani setiap pelanggan.

Gunakan Pendekatan Tinjauan Panjang

Penyelesaian alternatif kepada aliran adalah dengan melaksanakan pendekatan pengundian panjang. Teknik ini melibatkan pelanggan menghantar permintaan berterusan ke pelayan, yang memastikan sambungan hidup. Apabila acara berlaku pada pelayan, ia memberitahu semua pelanggan yang menunggu, menggesa mereka untuk menamatkan dan membuat permintaan baharu.

Sampel Kod untuk Tinjauan Panjang

Yang berikut sampel kod menggambarkan berapa lama pengundian boleh dilaksanakan dalam Python:

.PROTO Definisi

<code class=".PROTO">service Updater {
    rpc GetUpdates(GetUpdatesRequest) returns (GetUpdatesResponse);
}

message GetUpdatesRequest {
    int64 last_received_update = 1;
}

message GetUpdatesResponse {
    repeated Update updates = 1;
    int64 update_index = 2;
}

message Update {
    // Your update structure
}</code>
Salin selepas log masuk

Kod Pelayan

<code class="python">class UpdaterServer(UpdaterServicer):
    def __init__(self):
        self.condition = threading.Condition()
        self.updates = []

    def post_update(self, update):
        with self.condition:
            # Remove old updates after some time
            self.updates.append(updates)
            self.condition.notify_all()

    def GetUpdates(self, req, context):
        with self.condition:
            while self.updates[req.last_received_update + 1:] == []:
                self.condition.wait()
            new_updates = self.updates[req.last_received_update + 1:]
            response = GetUpdatesResponse()
            for update in new_updates:
                response.updates.add().CopyFrom(update)
            response.update_index = req.last_received_update + len(new_updates)
            return response</code>
Salin selepas log masuk

Benang Asingkan dalam Pelanggan

<code class="python">request = GetUpdatesRequest()
request.last_received_update = -1
while True:
    stub = UpdaterStub(channel)
    try:
        response = stub.GetUpdates(request, timeout=60*10)
        handle_updates(response.updates)
        request.last_received_update = response.update_index
    except grpc.FutureTimeoutError:
        pass</code>
Salin selepas log masuk

Contoh ini menunjukkan cara pelanggan boleh menggunakan tinjauan panjang untuk menerima kemas kini tanpa strim yang dimulakan oleh pelayan.

Atas ialah kandungan terperinci Bagaimana untuk Melaksanakan Penyiaran Pelayan-ke-Pelanggan gRPC dengan Tinjauan Panjang?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!

sumber:php.cn
Kenyataan Laman Web ini
Kandungan artikel ini disumbangkan secara sukarela oleh netizen, dan hak cipta adalah milik pengarang asal. Laman web ini tidak memikul tanggungjawab undang-undang yang sepadan. Jika anda menemui sebarang kandungan yang disyaki plagiarisme atau pelanggaran, sila hubungi admin@php.cn
Artikel terbaru oleh pengarang
Tutorial Popular
Lagi>
Muat turun terkini
Lagi>
kesan web
Kod sumber laman web
Bahan laman web
Templat hujung hadapan