FiveM CreateThread et Wait(0) expliqués : pourquoi votre script coûte des ms

Vous écrivez une boucle pour vérifier quelque chose, et le jeu cesse de répondre, ou resmon montre votre resource à quelques ms alors que vous êtes immobile :

while true do
    -- no Wait here: the game never gets control back
    local ped = PlayerPedId()
end

Cet article explique comment les threads et Wait fonctionnent dans Lua FiveM, ce que Wait(0) coûte vraiment, et comment écrire des boucles qui restent peu coûteuses.

#Comment les threads fonctionnent dans FiveM

Lua dans FiveM est coopératif. Votre script ne s'exécute pas en parallèle avec le jeu : il s'exécute quand le runtime l'appelle, et il doit redonner le contrôle. Deux choses rendent cela possible :

• Les gestionnaires d'événements et les callbacks s'exécutent une fois, du début à la fin, puis retournent.
• Les threads créés avec CreateThread sont de petites coroutines que le planificateur reprend encore et encore. Un thread redonne le contrôle quand il appelle Wait.

CreateThread(function()
    while true do
        Wait(1000)
        print('one second later')
    end
end)

CreateThread et Citizen.CreateThread sont la même fonction, et il en va de même pour Wait et Citizen.Wait. Utilisez celui que vous préférez, mais soyez cohérent dans un script.

#Une boucle while sans Wait gèle le jeu

Si un thread n'appelle jamais Wait, le planificateur n'obtient jamais le contrôle. Sur le client, le jeu cesse de dessiner les frames jusqu'à ce que la boucle se termine, et sur le serveur, chaque autre script attend le vôtre.

CreateThread(function()
    while true do
        -- missing Wait: this blocks the whole client
    end
end)

La même chose se produit avec une boucle repeat … until ou une longue boucle for qui effectue un travail lourd. Chaque boucle qui peut s'exécuter pendant un certain temps a besoin d'un Wait à l'intérieur. Si un script gèle le jeu au démarrage, cherchez d'abord une boucle comme celle-ci.

#Ce que coûte Wait(0)

Wait(0) signifie : pause jusqu'à la frame suivante (client) ou le tick suivant (serveur), puis continue. La boucle s'exécute à nouveau à chaque frame, donc à 60 fps, son corps est payé 60 fois par seconde.

CreateThread(function()
    while true do
        Wait(0)
        local coords = GetEntityCoords(PlayerPedId())
        local dist = #(coords - vector3(215.0, -810.0, 30.7))
        if dist < 3.0 then
            -- draw a marker, show text...
        end
    end
end)

Une boucle comme celle-ci coûte peu. Dix d'entre elles, réparties sur trente resources, s'accumulent à plusieurs ms de temps client, ce qui est exactement ce que resmon montre comme ms élevé. Le coût n'est pas le Wait(0) lui-même, c'est tout ce que vous répétez à chaque frame.

#Wait uniquement aussi court que vous en avez besoin

La plupart des vérifications n'ont pas besoin de s'exécuter à chaque frame. Demandez-vous à quoi sert la boucle :

L'astuce habituelle est deux vitesses : une boucle lente qui vérifie la distance, et une rapide uniquement quand le joueur est à l'intérieur de la zone.

local zone = vector3(215.0, -810.0, 30.7)

CreateThread(function()
    while true do
        local sleep = 1000
        local dist = #(GetEntityCoords(PlayerPedId()) - zone)

        if dist < 10.0 then
            sleep = 0
            DrawMarker(1, zone.x, zone.y, zone.z - 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
                1.5, 1.5, 0.5, 255, 255, 255, 120, false, false, 2, false, nil, nil, false)
        end

        Wait(sleep)
    end
end)

Loin de la zone, le thread se réveille une fois par seconde. Près d'elle, il dessine à chaque frame. Resmon tombe à presque rien pour la plupart des joueurs.

Conseil : avant de chercher une boucle plus rapide, demandez-vous si un événement ou un state bag peut vous dire quand la valeur change. Pas de boucle du tout est moins cher que n'importe quel Wait.

#SetTimeout : exécuter quelque chose une fois, plus tard

Si vous n'avez besoin de faire quelque chose qu'une seule fois après un délai, vous n'avez pas besoin d'un thread avec un Wait :

SetTimeout(5000, function()
    print('five seconds later')
end)

SetTimeout(ms, callback) exécute le callback une fois après le délai et ne bloque rien. Il existe aussi sur le serveur. Pour une tâche répétitive, un thread avec Wait est le bon outil, puisque SetTimeout ne se répète pas d'lui-même.

#Attendre à l'intérieur des gestionnaires d'événements

Un gestionnaire d'événements peut aussi appeler Wait, car FiveM l'exécute dans sa propre coroutine. Soyez prudent sur le serveur : après un Wait, le source global ne pointe plus vers le joueur qui a déclenché l'événement. Sauvegardez-le d'abord (voir événements client et serveur):

RegisterNetEvent('my_script:server:buy', function()
    local src = source
    Wait(500)
    print(('player %s bought something'):format(src))
end)

#Arrêter un thread

Un thread se termine quand sa fonction retourne. Pour arrêter une boucle de l'extérieur, utilisez un drapeau que la boucle vérifie :

local running = true

CreateThread(function()
    while running do
        Wait(500)
        -- work
    end
end)

AddEventHandler('onResourceStop', function(resource)
    if resource == GetCurrentResourceName() then
        running = false
    end
end)

Tous les threads d'une resource s'arrêtent d'eux-mêmes quand la resource s'arrête, donc vous n'avez besoin de cela que pour arrêter une boucle pendant que la resource continue de s'exécuter.

#Liste de contrôle