Long polling czy WebSockety? Co się sypało w grze multiplayer

W 2022 roku napisałem imprezową grę karcianą online w stylu Cards Against Humanity, w czystym PHP, jQuery i MySQL. Do aktualizacji na żywo trzeba było coś wybrać, long polling czy WebSockety, i wziąłem long polling. Gra działała i grało w nią naraz 200 osób na serwerze w Hetznerze, ale trzymała się na słowo honoru. Long polling wystarcza, kiedy zmiany są rzadkie i idą w jedną stronę. W grze multiplayer, w której wielu graczy co kilka sekund zmienia wspólny stan, sypał się w czterech miejscach i dziś tę samą grę postawiłbym na WebSocketach.

Najważniejsze

  • Long polling trzyma request HTTP otwarty, dopóki serwer nie ma nowości. W PHP każdy czekający klient zajmuje do tego przez cały ten czas jeden proces.
  • Gra co 0,6 s pytała bazę o zmiany dla każdego gracza. Przy 200 graczach to około 1000 zapytań na sekundę tylko po to, żeby sprawdzić, czy coś się zmieniło.
  • Wykrywanie zmian przez porównywanie znaczników czasu dawało lagi i rozjechany stan gry między graczami.
  • WebSockety trudniej postawić, ale serwer wysyła zdarzenie do całego pokoju od razu, kiedy coś się dzieje.
  • Long polling sprawdzi się przy rzadkich aktualizacjach z serwera albo w sieciach, które blokują WebSockety. Do wszystkiego, co interaktywne, bierz WebSockety.

Jak działał long polling w mojej grze

Klient wysyłał request do game_polling.php, a serwer nie odpowiadał, dopóki coś się nie zmieniło. W środku pętla while (true) co 0,6 sekundy sprawdzała stan lobby:

while (true) {
    // ... czy gracz jest dalej w lobby? czy lobby zostało zresetowane?
    $sql = "SELECT * FROM lobby WHERE (last_change > :time_change
            OR last_change_players > :time_change2
            OR last_change_round > :time_change3) AND lobby_id = :id";
    // ... jeśli przyszedł wiersz: zbuduj odpowiedź, wypisz ją, exit

    if ($counter == 3600) {
        echo $time;
        exit();
    }
    usleep(600000);
}

Jeśli przez 3600 obrotów, czyli około 36 minut, nic się nie zmieniło, pętla zwracała stary znacznik czasu, a przeglądarka otwierała nowy request. Po stronie klienta $.ajax z jQuery po każdej odpowiedzi odpalał polling() od nowa. Każda akcja w grze, na przykład zagranie karty, wybór zwycięzcy albo wyrzucenie gracza, była osobnym skryptem PHP, który zapisywał zmianę w MySQL i ustawiał last_change na aktualny czas w milisekundach. Pętle pollingu zauważały nowszy znacznik i rozsyłały aktualizację.

Diagram sekwencji: moja gra odpytuje serwer co 0,6 s, obok ten sam przepływ przez jedno połączenie WebSocket

Gdzie się sypało

Sypało się w czterech miejscach: lagi, obciążenie bazy, stan gry inny u każdego gracza i łatki po stronie klienta.

Lag z samego założenia

Zmianę było widać dopiero przy następnym obrocie pętli, czyli nawet 0,6 s później. Do tego dochodził czas odpowiedzi i nowy request, który przeglądarka otwierała zaraz po niej. W grze, w której wszyscy czekają na najwolniejszego gracza, było to czuć.

Czekanie spadało na bazę

Każdy obrót pętli robił trzy zapytania SELECT na gracza. Przy 0,6 s na obrót to około 5 zapytań na sekundę na gracza, a przy 200 graczach mniej więcej 1000 zapytań na sekundę. Prawie wszystkie kończyły się odpowiedzią „nic się nie zmieniło”. Do tego każdy czekający gracz trzymał jeden proces PHP, dopóki request był otwarty. RFC 6202 wymienia ten koszt wśród znanych problemów long pollingu: serwer trzyma zasoby dla każdego oczekującego requestu.

Stan gry się rozjeżdżał

Zmiany wykrywałem, porównując znaczniki czasu w milisekundach, a zapisywały je różne requesty. Skrypt zapisujący brał czas na starcie, ale sam zapis mógł trafić do bazy już po tym, jak pętla pollingu przesunęła swój znacznik dalej. Takiej zmiany nie widział wtedy nikt. Na koniec rundy było jeszcze gorzej: jeden request tasował karty, a drugi w tym samym momencie próbował je odczytać. Moja poprawka, po skróceniu:

// Problem
$stmt->execute(['id' => $id]);
if ($stmt->rowCount() == 0) {
    usleep(100000);
    $stmt->execute(['id' => $id]);
}

Kod czeka 100 ms i liczy na to, że drugi request już skończył. Zwykle kończył, a jak nie, gracze mieli na ręce różne karty.

Łatki po stronie klienta

Klient też miał swoje obejścia. Jeśli odpowiedź zaczynała się od <, znaczyło to, że PHP wypisał błąd w HTML-u, więc klient po prostu pytał jeszcze raz. Jeśli miała dokładnie 13 znaków, był to znacznik czasu, czyli „nic się nie stało, zapytaj znowu”. Każdy błąd sieci kończył się alertem i przeładowaniem całej strony.

Czemu w ogóle long polling

Wziąłem long polling, bo nie umiałem WebSocketów i trochę się ich bałem. Mogłem dzięki temu zostać przy tym, co znałem: zwykłych skryptach PHP i AJAX-ie.

Próg wejścia przy WebSocketach faktycznie jest wyższy. Potrzebny jest proces, który działa cały czas i trzyma połączenia, a klasyczne PHP, gdzie skrypt żyje tylko przez jeden request, tego nie daje. Ponowne łączenie, heartbeaty i uwierzytelnianie na sockecie trzeba obsłużyć samemu. Do tego proxy przed serwerem musi przepuścić handshake Upgrade.

Nie policzyłem, ile ten skrót będzie mnie kosztować później. Każdą godzinę, którą zaoszczędziłem, nie ucząc się WebSocketów, oddałem z nawiązką na szukanie lagów i rozjazdów stanu między graczami.

Ta sama gra na WebSocketach

Przy WebSocketach każdy gracz trzyma jedno otwarte połączenie, a serwer trzyma stan gry w pamięci, jeden obiekt na pokój. Ruch gracza przychodzi jako wiadomość, serwer sprawdza go z aktualnym stanem, wprowadza zmianę i wysyła wynik wszystkim w pokoju. Nikt nie odpytuje bazy w kółko, a znaczniki czasu porozrzucane po tabelach zastępuje jedno miejsce, w którym leży stan gry.

Minimalna wersja w TypeScripcie z biblioteką ws:

import { WebSocketServer, type WebSocket } from "ws";

type Room = { players: Set<WebSocket>; version: number };
const rooms = new Map<string, Room>();
const server = new WebSocketServer({ port: 8080 });

server.on("connection", (socket, request) => {
  const roomId = new URL(request.url ?? "/", "http://localhost").searchParams.get("room") ?? "lobby";
  const room = rooms.get(roomId) ?? { players: new Set(), version: 0 };
  rooms.set(roomId, room);
  room.players.add(socket);

  socket.on("message", (data) => {
    const move = JSON.parse(String(data));
    room.version += 1;
    const update = JSON.stringify({ version: room.version, move });
    room.players.forEach((player) => player.send(update));
  });

  socket.on("close", () => room.players.delete(socket));
});

Pełna gra przed rozesłaniem sprawdza jeszcze ruch i zapisuje go w stanie pokoju. Numer version pozwala klientowi, który połączył się ponownie, zapytać o to, co go ominęło. A kiedy jeden serwer przestanie wystarczać, zdarzenia między instancjami można przesyłać przez pub/sub, na przykład w Redisie.

Long polling czy WebSockety, a gdzie polling i SSE

Kierunek Opóźnienie Koszt po stronie serwera Do czego
Polling klient pyta co określony czas do długości interwału request co interwał, zwykle pusty dashboardy odświeżane co minutę
Long polling serwer odpowiada, gdy ma nowość niskie, plus nowy request po każdej odpowiedzi jeden otwarty request na klienta, w klasycznym PHP do tego proces rzadkie aktualizacje, sieci blokujące WebSockety
Server-sent events tylko z serwera do klienta niskie jedno otwarte połączenie HTTP na klienta powiadomienia, feedy na żywo, postęp zadań
WebSockety w obie strony niskie jedno otwarte połączenie na klienta, tanie wiadomości gry, czaty, wspólna edycja

Moja gra potrzebowała komunikacji w obie strony i częstych zmian wspólnych dla całego pokoju, czyli ostatniego wiersza.

Co zrobiłbym inaczej

Zacząłbym od WebSocketów i trzymał stan gry w pamięci serwera, a nie w wierszach MySQL ze znacznikami czasu. W bazie zostawiłbym tylko to, co musi przetrwać restart: konta, talie kart i zakończone gry. I nie pozwoliłbym, żeby o architekturze zdecydował za mnie strach przed nowym narzędziem. WebSockety, których tak unikałem, okazały się prostsze niż wszystkie obejścia, które napisałem, żeby ich nie używać.

  • websockety
  • long polling
  • php
  • real-time
  • multiplayer

Autor

Bartosz Świtała

Lead Backend Developer w Full Stack House. Buduję backendy w NestJS, płatności, wyszukiwarki i integracje, a tutaj piszę o tym, co się zepsuło i czego się przy tym nauczyłem.