void pr(lua_State * A)
{thread athr1(newpotok, A); athr1.detach();}
   

static int forLua_runMAIN1(lua_State * A)
{thread athr(pr, A);athr.join(); return(0);}

#define STRICT
#define WIN32_LEAN_AND_MEAN
#define VC_EXTRALEAN
#define NOMINMAX
#define WINVER 0x0600
#define _WIN32_WINNT WINVER
#include <Windows.h>
#include <process.h>

extern "C"
{
#include "luaconf.h"
#include "lua.h"
#include "lauxlib.h"
}

#pragma comment(lib, "lua5.1.lib")

// здесь будет храниться ссылка на стейт нового потока.
// глобальная переменная - плохое решение, но для демки сойдет,
// более интересные варианты только добавят ненужной здесь сложности
static int tref = LUA_NOREF;

// это "полезная" функция, выполняемая в новом потоке
static void some_useful_function(lua_State * s)
{
   // показываем сообщение о запуске
   lua_getglobal(s, "message");
   lua_pushliteral(s, "Эта функция выполняется в новом потоке. Выполняется, выполняется...");
   lua_call(s, 1, 0);
   // три секунды имитируем бурную деятельность
   ::Sleep(3000);
   // показываем сообщение об остановке
   lua_getglobal(s, "message");
   lua_pushliteral(s, "    ...кончила выполняться.");
   lua_call(s, 1, 0);
}

// это стартовая функция для нашего нового потока
static unsigned int __stdcall thrd(void * pvoid)
{
   // сохраняем переданный стейт.
   // обратите внимание, что в этом потоке мы работаем только со стейтом,
   // созданным специально для этого потока. мы никогда не трогаем стейты
   // других потоков и другие потоки не должны трогать наш стейт
   lua_State * n = static_cast<lua_State *>(pvoid);
   // вызываем "полезную" функцию, передавая ей свой стейт
   ::some_useful_function(n);
   // освобождаем ссылку на свой стейт, чтобы коллектор мог его прибить. если
   // этого не сделать, стейт доживет до закрытия квика даже после остановки
   // запустившего нас [в огород] скрипта (т.е. будет утечка памяти)
   luaL_unref(n, LUA_REGISTRYINDEX, ::tref);
   ::tref = LUA_NOREF;
   // с этого момента коллектор имеет право прибить наш стейт когда хочет, т.е.
   // для нас его уже не существует, хотя, возможно, где-то в дебрях квика он
   // еще будет болтаться некоторое время
   n = nullptr;
   // сейчас мы вернем управление и поток будет прибит. это приведет к тому, что
   // хэндл потока, на котором ждет наш main, перейдет в состояние signaled,
   // функция WaitForSingleObject вернет управление и main будет разблокирован
   return 0;
}

// это main для квика (внезапно сишный)
static int qmain(lua_State * s)
{
   // создаем новый стейт для потока.
   // стейт также появится на вершине стека s
   lua_State * n = lua_newthread(s);
   // создаем ссылку на стейт, чтобы коллектор случайно не прибил его раньше времени.
   // функция также выдернет стейт n с вершины стека s, вернув стек s в состояние,
   // в котором он был до вызова lua_newthread
   ::tref = luaL_ref(s, LUA_REGISTRYINDEX);
   // создаем нативный поток и передаем ему созданный стейт n
   unsigned int tid;
   HANDLE h = reinterpret_cast<HANDLE>(::_beginthreadex(NULL, 0, ::thrd, n, CREATE_SUSPENDED, &tid));
   if(NULL == h)
   {
      // в случае ошибки поток не создан, поэтому не забываем прибить ссылку на новый стейт,
      // иначе он останется в памяти до завершения квика (утечка памяти)
      luaL_unref(s, LUA_REGISTRYINDEX, ::tref);
      ::tref = LUA_NOREF;
      luaL_error(s, "_beginthreadex failed");
   }
   // обратите внимание, что в текущем потоке трогать стейт n больше нельзя, у него теперь новый хозяин,
   // который позаботится также и о его освобождении. поэтому мы сразу же обнуляем указатель на стейт,
   // чтобы случайные попытки туда влезть вызывали крэш
   n = nullptr;
   // запускаем новый поток на выполнение
   ::ResumeThread(h);
   // здесь main может делать что-то другое, второй поток работает параллельно. но
   // перед тем, как из мейна выйти, нужно убедиться, что все дополнительные потоки уже завершены.
   // по-хорошему им сначала надо как-то посигналить "все бросай и на выход бегом", а уже потом ждать, но
   // мы не будем лезть в дебри в рамках простой демки. поскольку нам в main особо делать нечего, мы сразу
   // переходим к ожиданию завершения второго потока. попробуйте закомментировать следующую строку, если
   // хотите посмотреть, как через три секунды к квику придет внезапный полярный зверек
   ::WaitForSingleObject(h, INFINITE);
   // не забываем закрыть хэндл потока, иначе он доживет до закрытия квика (утечка хэндла)
   ::CloseHandle(h);
   return 0;
}

extern "C" __declspec(dllexport) int qtest(lua_State * s)
{
   // мы хотим, чтобы в качестве колбека main работала наша сишная qmain
   lua_pushcclosure(s, qmain, 0);
   lua_setglobal(s, "main");
   return 0;
}

static int forLua_runMAIN1(lua_State* L)
{  
    lua_State* L1 = lua_newthread(L);
    lua_getglobal(L1, "main1");
    lua_pcall(L1, 0, 0, 0);   
    return (0); 
}

  static int forLua_runMAIN1(lua_State *  L)
{  
    lua_State *  L1  =  lua_newthread(L);
    lua_getglobal(L1,  "main1" );
    lua_pcall(L1,  0 ,  0 ,  0 );   
     return  ( 0 ); 
}
  

static int forLua_runMAIN1(lua_State* L)
{  
    lua_State* L1 = lua_newthread(L);
    lua_getglobal(L1, "main1");
    lua_pcall(L1, 0, 0, 0);   
    return (0); 
}

получилось? это в 32 бит версии могло такое прокатить

   
    lua_State* L1 = lua_newthread(L);
    lua_gc(L1, LUA_GCSTEP, 100); // выполняет постепенный этап сбора мусора
    lua_pushstring(L1, "main1");//Находит в стеке Lua функцию по ее названию и помещает ее наверх стека
    lua_gettable(L1, LUA_GLOBALSINDEX);
    lua_pcall(L1, 0, 0, 0);

void newpotok(lua_State* L)
{
   while (lua_isfunction(L, 1) != 1)
   {
     lua_getglobal(L, "main1"); Sleep(100); // ТУТ ЦИКЛ ТК НЕ ВСЕГДА НАХОДИТ НУЖНУЮ ФУНКЦИЮ ПРАВДА В ЭТОМ СОСТОЯНИИ ФУНКЦИЯ РАБОТАЕТ
   }


   lua_State* L1 = lua_newthread(L);
   lua_settop(L1, 0);// уст кол-во элементов в стеке. 0 - очистить стек.

   while (lua_isfunction(L1, 1) != 1)
        {
           lua_xmove(L, L1, 1);); ТУТ МЕНЯЛ ЗНАЧЕНИЯ МЕСТАМИ НИ ЧЕГО ПЕРЕДАЧА ФУНКЦИИ ДРУГОМУ ПОТОКУ
      lua_getglobal(L1, "main1"); Sleep(100); // 
   }

    lua_pcall(L1, 0, 0, 0);  //////////// НЕ ПОЛУЧАЕТСЯ ВЫПОЛНИТЬ ////////////////////////////////////////////////////////////////////////
   

};

static int forLua_runMAIN1(lua_State* L)
{
   std::thread thr(newpotok, L); //Запускает выполнение функции MyCallback() в отдельном потоке
   thr.detach(); //Отсоединяет созданный поток от основного, делая его "фоновым"
   return (0); //Завершает работу функции forLua_StartCallback, при этом функция MyCallback продолжает работать в отдельном потоке
}