Interactuar con un estado lua en ejecución desde un subproceso diferente no es necesariamente seguro, por lo que modificar la variable global del script puede o no ser una idea útil dependiendo de dónde planee realizar ese cambio desde el lado C.

Si quisiera hacer esto, simplemente necesitaría usar la API lua Cap para establecer la variable global del nombre apropiado en el estado lua apropiado.

Una idea alternativa sería crear una función global should_exit que se llama al principio o al final de cada ciclo y cuando devuelve verdadero hace que el código lua se break o return . Esta función puede verificar cualquier cosa que quiera en el lado C de cualquier manera apropiada para el subproceso que se desee.

¿Por qué tener este bucle en Lua? En su lugar, puede hacer un bucle en c-thread, lua_pcall alguna función de punto de entrada (por ejemplo onEvent() ) en cada iteración.

Si el bucle tiene que estar en el script Lua, por ejemplo, en el caso de un esquema de configuración-bucle-limpieza, puede ejecutar el script en coroutine y usar coroutine.yield() como condición de bucle. El hilo debe lua_resume() con valor true o salir según la condición del lado c. (O reanude con false si se prefiere la limpieza del lado de Lua después del ciclo).

De todos modos, Lua no es seguro para subprocesos y no se puede llamar simultáneamente desde más de un subproceso.

Oh, fuiste muy duro en tu respuesta (sin embargo, seguro que fue un gran ejercicio). Las cosas podrían ser mucho más simples:

 #include <pthread.h> #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <lua.h> #include <lauxlib.h> #include <lualib.h> static volatile int shouldRun = 1; // 1. static int fn_sleep(lua_State *L) { lua_Integer n = luaL_checkinteger(L, 1); sleep(n < 0 ? 0 : n); return 0; } static int fn_shouldRun(lua_State *L) { lua_pushboolean(L, shouldRun); return 1; } static void * thread_main(void *dummy) { lua_State *L = luaL_newstate(); luaL_openlibs(L); lua_register(L, "sleep", fn_sleep); // 2. lua_register(L, "shouldRun", fn_shouldRun); if (luaL_dofile(L, "script.lua")) { fprintf(stderr, "%s\n", lua_tostring(L, -1)); lua_pop(L, 1); } lua_close(L); // 3. return 0; } int main(int argc, char *argv[]) { pthread_t thread; pthread_create(&thread, NULL, thread_main, NULL); sleep(5); shouldRun = 0; // 1. pthread_join(thread, NULL); return 0; }

guión.lua:

 print("Hi!") while shouldRun() do print("Running!") sleep(1) end print("Bye!")

producción:

 Hi! Running! Running! Running! Running! Running! Bye!

Algunas cosas a tener en cuenta:

1. Las condiciones de salida encuestadas normalmente no necesitan ninguna protección. Si se llamó a shouldRun() simultáneamente con la actualización de variables y se perdió, entonces no hay de qué preocuparse: devolverá falso la próxima vez. De todos modos, ni siquiera puede adivinar dónde se está ejecutando el script, simplemente [re]establezca el valor y espere a que finalice.
2. Para un par de funciones específicas no es necesario escribir un módulo compatible con require/preload. Exportarlos a un espacio de nombres global en su lugar.
3. Para un cierre elegante en caso de error, no solo exit() . lua_close() recolectará basura todos los datos de usuario utilizados por el script, y su metamétodo __gc puede hacer algo útil como vaciar los búferes en el disco, etc. Pierde todas las posibilidades con una salida forzada.