lua多线程共享数据的解决方案
本人表达能力有限，所以文字描述不太清晰，我更习惯自己默默地造轮子，所以我只能尽力保证我给轮子可以被直接使用。
虽然不太会说，但有一些前提还是必要讲一下的：
直观的讲：lua并不支持多线程，任何尝试用lua做并发方案的人，都有病，没错，我自己也是。
lua有并发需求本身就是一件很鬼扯的事，本身会有这种需求，就说明可能在项目架构的大方向上，存在了问题。
我认为对于C/C++程序员来说，我们看中lua的地方是，它能够用最小的代价与C/C++交互，能够由C/C++去弥补它的不足，
所以，它能够包容所有对它理解程度不一样的C++程序员，
你不会用lua来解决一个问题，没关系，你懂得C/C++的办法，你给lua公开一套接口，说不定解决的还更完美。
虽然从另外一个角度来看，这是一种脱裤子放屁的行为，
但你得知道，维护C++代码的代价，与维护lua代码的代价是不同的，C++乱了，你自己解决起来可能都是大问题，而lua是不怕乱的，除非是写C++的人乱搞。
所以说这么多，我个人有这种需求的理由是：我正在用lua来做并发服务端的业务逻辑，已经跑题太多了，我只简单说一下：
C++实现套接字IO >> 传递json作为文本协议 >> 解析成lua table >> lua执行业务逻辑
在lua执行业务逻辑的过程中，就对共享数据有需求了，例如用户login之后的数据由lua来管理。
解决方案共两种：
1、基于lua_newthread创建lua子对象，重定义lua源码中的lua_lock与lua_unlock宏。
优点：这种方案的外表是完美无缺的。
缺点：降低lua的整体运行速度，因为我们使用了加锁的方式去维护lua的gc机制，并且我个人认为代价很大。
这种方案是我最初设计方案，但由于不能忍受一次请求上百次加锁操作，我最终放弃了这个方案。
我懒，不想把这种已经放弃掉的方案往这边搬了，如果非常有必要，劳您移驾传送门。
2、将共享数据存储在C/C++或一个公共的lua_State对象中，利用lua元表实现共享table存取逻辑。
优点：具有最高的可维护性，因为是基于lua api实现，和lua版本无关。
缺点：局限性最大。
这是我目前正在使用的方案，如下：
请注意，本例基于c++17标准实现，用到了 std::variant
否则，请自行实现支持hash的变体结构，或者使用一个公共lua_State对象来实现交互逻辑。
在Microsoft Visual Studio中，C++标准版本的设置在：项目 - 属性 - C/C++ - 语言 - C++语言标准中
使用g++时，可以在命令行中直接设置。
由于之前的代码存在许多不安全因素，因此我重构了一次代码(2020/07/27)，以下是全新的代码，库代码仅一个文件:lxsharelib.hpp
C++中使用 lua_openxsharelib(L);
lua中:
local xst = xshare.new(name); -- 创建一个共享数据表
xshare.pcall(xst,function[,args...]); -- 基本与lua的pcall保持一致，但是在执行function之前，会先进行加锁
xshare.mutex(xst, func); -- 会返回一个新的函数，这个新的函数被调用时加锁，然后调用func。
xshare.istab(xst); -- 判断一个变量是不是共享数据表，在C++中通过upvalue上存放的元表指针 与 xst的元表指针进行对比来确定。
xshare.islife(xst); -- 判断一个共享数据表是否还存活，xst本身只是一种引用对象，如果有其他线程将xst指向的共享表删除了，xst也就同时死亡了。
local t = xshare.swap(xst[, luatable]); -- 可与lua table交换数据，返回值是旧的共享数据表完全拉取的lua table，如果不指定参数2，就是单纯的完整拉取共享数据表到返回值的table中
xshare.clear(xst); -- 清空一个共享数据表，类似 t={}的机制
其余机制基本与lua table操作一致，共享数据表支持的index类型(number boolean string)，支持的value类型(number boolean string table)
示例：
xst.a = 100;
xst.b = {1,2,3}
这次的一些实现细节和变化：
共享table操作的过程中，增删改查都是加锁的，所以，已经不再提供lock unlock这种接口，这么改的理由是lua难以保证lock unlock对称执行。
xshare.pcall 与 xshare.swap 相结合，在并发环境下，能够实现类似事务处理的机制。
给lua的数据引用对象由之前的table换成了userdata，同时强制依赖的预定义的元方法。
这就表示，xshare共享数据表基本丧失了可重定义元方法的机制，
如果非要重定义元方法，需要重新设置所有xshare在C++向lua提供的函数(包括元方法)中的第1个upvalue，这个upvalue就是预定义的元表。
在上一次我写的代码中，单纯的就是保留容器指针，这是最重要的不安全因素。
一个线程将一个子共享表设置为nil时，如果另一个线程中，还保留了这个子表的引用指针，就导致了这个指针悬垂。
为了解决这个问题:
1、我在根共享表下保存了一个引用对象指针链表，根共享表是由xshare.new创建的，常规的情况下不能被删除的，只能做清空处理。
2、由lua userdata保存引用对象，引用对象包含了共享数据容器指针，引用对象指针链表的迭代器。
3.1、为userdata提供 __gc 回调，__gc回调触发时，将引用对象指针从链表中删除，并将迭代器设置为end()
3.2、当其他线程将子共享表设置为nil时，共享表对象析构时遍历这个链表，将对应容器指针的引用全部从链表中删除，并将引用对象内的迭代器设置为end()。
这么做，C++中的数据表指针与引用对象就形成了闭环，任意一方对共享表进行删除操作，都会导致所有引用失效。
#pragma once #include "lua.hpp" #include <mutex> #include <variant> #include <unordered_map> #include <string> namespace lxshare_internal { // 两个用于加锁的类定义，在g++下，应该自己用操作系统实现这两个类 using _MtxTy = typename std::recursive_mutex; using _LockTy = typename std::lock_guard<_MtxTy>; using xbool = unsigned char; using xuserdata = unsigned long long*; class xtable; using xvalue = std::variant<std::string, intptr_t, double, xbool, xtable*, xuserdata>; using xkey = std::variant<std::string, intptr_t, double, xbool, xuserdata>; static bool __xkey_types[10] = { false, // LUA_TNONE false, // LUA_TNIL true, // LUA_TBOOLEAN true, //LUA_TLIGHTUSERDATA true, //LUA_TNUMBER true, //LUA_TSTRING false, //LUA_TTABLE false, //LUA_TFUNCTION false, //LUA_TUSERDATA false, //LUA_TTHREAD }; static bool _islxkey(int _Type) { return __xkey_types[_Type + 1]; } static xkey _lxkey(lua_State* s, int idx) { int _Type = lua_type(s, idx); switch (_Type) { case LUA_TNUMBER: if (!lua_isinteger(s, idx)) return lua_tonumber(s, idx); else return lua_tointeger(s, idx); case LUA_TSTRING: return lua_tostring(s, idx); case LUA_TBOOLEAN: return (xbool)lua_toboolean(s, idx); case LUA_TLIGHTUSERDATA: return (xuserdata)lua_touserdata(s, idx); } return (intptr_t)0; } class xtable { public: class reftype; using _Tabty = typename std::unordered_map<xkey, xvalue>; using _RefIterator = typename _Tabty::iterator; struct _RSTAT { _MtxTy mtx; std::list<reftype*> refs; xtable* root = nullptr; }; class reftype { public: xtable* ref() { return (v != rs->refs.end()) ? t : nullptr; } void unref() { auto& refs = rs->refs; if (v == refs.end()) return; refs.erase(v); v = refs.end(); } _MtxTy& mtx() { return rs->mtx; } xtable* t; std::list<reftype*>::iterator v; _RSTAT* rs; }; xtable() { // 只有在创建根共享表时，才会用这个无参数的默认构造 iMax = 0; rs = new _RSTAT; rs->root = this; } xtable(xtable* t) { // 创建子共享表的构造 iMax = 0; rs = t->rs; } ~xtable() { for (auto it = rs->refs.begin(); it != rs->refs.end(); ) { reftype* p = *it; if (p->t == this) { p->v = rs->refs.end(); it = rs->refs.erase(it); } else ++it; } rs->refs.clear(); if (rs->root != this) { clear(); return; } } _RefIterator begin() { return tab.begin(); } _RefIterator end() { return tab.end(); } _RefIterator find(const xkey& k) { return tab.find(k); } void clear() { for (auto it = tab.begin(); it != tab.end(); ++it) { if (it->second.index() == 4) delete (std::get<4>(it->second)); } tab.clear(); } void new_table(lua_State* s, const char *_Name) { _LockTy lg(rs->mtx); auto it = tab.find(_Name); if (it == tab.end()) it = tab.insert({ lua_tostring(s, 1), new xtable(this) }).first; std::get<4>(it->second)->put_ref(s); } void get_table(lua_State* s, xkey &k) { auto it = tab.find(k); if (it == tab.end()) { put_nil(s); return; } put_val(s, it->second); } int set_table(lua_State* s, xkey& k, int n) { auto it = tab.find(k); if (it == tab.end()) { if (lua_isnil(s, n)) { // tab.key = nil; return 0; } it = tab.insert({ k, xvalue() }).first; int rc = xtable::take_val(s, n, it->second); if (rc) tab.erase(it); else imax_check(k); return rc; } else { // 已经存在的key if (lua_isnil(s, n)) { if (it->first.index() == 1) { if (std::get<1>(it->first) == iMax) iMax--; } tab.erase(it); return 0; } if (it->second.index() == 4) { // 如果它是table xtable* t = std::get<4>(it->second); // 如果当前要插入的值也是table，就只对它做清空动作，否则就删除它 if (lua_istable(s, n)) t->clear(); else delete t; } int rc = xtable::take_val(s, n, it->second); if (rc) tab.erase(it); return rc; } } intptr_t getn() { // 基本思路是，只有最坏的情况，才开始用二叉查找法去计算当前最大的一个数字key if (iMax == 0) return 0; intptr_t k = iMax; auto it = tab.find(xkey((intptr_t)k)); if (it != tab.end()) return k; intptr_t n = 0; while (k - n) { intptr_t m = (k + n) >> 1; auto it = tab.find(xkey((intptr_t)m)); if (it == tab.end()) k = m; else n = m; } iMax = n; return n; } int swap_tab(lua_State* s, int n) { tab.clear(); return take_tab(s, n); } void toluatable(lua_State* s) { lua_createtable(s, (int)tab.size(), 0); for (auto it = tab.begin(); it != tab.end(); ++it) { put_key(s, it->first); if (it->second.index() == 4) std::get<4>(it->second)->toluatable(s); else put_val(s, it->second); lua_settable(s, -3); } } private: void imax_check(xkey& k) { if (k.index() == 1) { size_t n = std::get<1>(k); if (n > iMax) iMax = n; } } static int take_val(lua_State* s, int n, xvalue &v) { int _Type = lua_type(s, n); xtable* t = nullptr; switch (_Type) { case LUA_TBOOLEAN: v = (xbool)lua_toboolean(s, n); break; case LUA_TNUMBER: if (lua_isinteger(s, n)) v = lua_tointeger(s, n); else v = lua_tonumber(s, n); break; case LUA_TSTRING: v = lua_tostring(s, n); break; case LUA_TTABLE: t = new xtable; v = t; return t->take_tab(s, (n > 0) ? n : -2); case LUA_TLIGHTUSERDATA: v = (xuserdata)lua_touserdata(s, n); break; default: return (n < 0) ? -2 : -3; } return 0; } int take_tab(lua_State* s, int n) { lua_pushnil(s); int _Result = 0; while (lua_next(s, n)) { if (!_islxkey(lua_type(s, -2))) { lua_pop(s, 2); return -1; } xkey key = _lxkey(s, -2); imax_check(key); auto itval = tab.insert({ key, xvalue() }).first; int rc = xtable::take_val(s, -1, itval->second); lua_pop(s, 1); if (rc) return rc; } return 0; } private: void put_ref(lua_State* s) { reftype* p = (reftype*)lua_newuserdata(s, sizeof(reftype)); rs->refs.push_front(p); *p = { this, rs->refs.begin(), rs }; lua_pushvalue(s, lua_upvalueindex(1)); lua_setmetatable(s, -2); } public: static void put_nil(lua_State* s) { lua_pushnil(s); } static void put_val(lua_State* s, xvalue &v) { switch (v.index()) { case 0: lua_pushstring(s, std::get<0>(v).c_str()); break; case 1: lua_pushinteger(s, std::get<1>(v)); break; case 2: lua_pushnumber(s, std::get<2>(v)); break; case 3: lua_pushboolean(s, (bool)std::get<3>(v)); break; case 4: std::get<4>(v)->put_ref(s); break; case 5: lua_pushlightuserdata(s, std::get<5>(v)); break; default: lua_pushnil(s); break; } } static void put_key(lua_State* s, const xkey& k) { switch (k.index()) { case 0: lua_pushstring(s, std::get<0>(k).c_str()); break; case 1: lua_pushinteger(s, std::get<1>(k)); break; case 2: lua_pushnumber(s, std::get<2>(k)); break; case 3: lua_pushboolean(s, (bool)std::get<3>(k)); break; case 4: lua_pushlightuserdata(s, std::get<4>(k)); break; default: lua_pushnil(s); break; } } private: _Tabty tab; size_t iMax; _RSTAT *rs; friend int xshare_new(lua_State* s); }; // 这里的xRoot是一个仅在C++中存在的根共享表 static xtable xRoot; // __gc static int xtable_gc(lua_State* s) { auto _Ref = (xtable::reftype*)lua_touserdata(s, 1); auto& _Mtx = _Ref->mtx(); _Mtx.lock(); _Ref->unref(); _Mtx.unlock(); return 0; } // __index static int xtable_index(lua_State* s) { auto _Ref = (xtable::reftype*)lua_touserdata(s, 1); auto& _Mtx = _Ref->mtx(); _Mtx.lock(); auto t = _Ref->ref(); if (!t) { _Mtx.unlock(); return luaL_error(s, "xshare table __index: 共享数据表引用已失效!"); } int _Type = lua_type(s, 2); if (!_islxkey(_Type)) { _Mtx.unlock(); return luaL_error(s, "xshare table __index: 不支持类型 %s 作为索引! (支持的类型为 number string boolean lightuserdata)", lua_typename(s, _Type)); } xkey k = _lxkey(s, 2); t->get_table(s, k); _Mtx.unlock(); return 1; } // __newindex static int xtable_newindex(lua_State* s) { auto _Ref = (xtable::reftype*)lua_touserdata(s, 1); auto& _Mtx = _Ref->mtx(); _Mtx.lock(); auto t = _Ref->ref(); if (!t) { _Mtx.unlock(); return luaL_error(s, "xshare table __newindex: 共享数据表引用已失效!"); } int _Type = lua_type(s, 2); if (!_islxkey(_Type)) { _Mtx.unlock(); return luaL_error(s, "xshare table __newindex: 不支持类型 %s 作为索引! (支持的类型为 number string boolean lightuserdata)", lua_typename(s, _Type)); } xkey k = _lxkey(s, 2); int rc = t->set_table(s, k, 3); _Mtx.unlock(); if (rc == -1) return luaL_error(s, "xshare table __newindex: 字段中存在无效的索引类型"); else if (rc == -2) return luaL_error(s, "xshare table __newindex: 字段中存在无效的共享类型"); else if (rc == -3) return luaL_error(s, "xshare table __newindex: 无效的共享类型(支持的类型为 boolean number string table lightuserdata)"); return 0; } // __len static int xtable_len(lua_State* s) { auto _Ref = (xtable::reftype*)lua_touserdata(s, 1); auto& _Mtx = _Ref->mtx(); _Mtx.lock(); auto t = _Ref->ref(); if (!t) { _Mtx.unlock(); return luaL_error(s, "xshare table __len: 共享数据表引用已失效!"); } lua_pushinteger(s, t->getn()); _Mtx.unlock(); return 1; } // __pairs static int xtable_pairs(lua_State* s) { lua_pushvalue(s, lua_upvalueindex(1)); lua_pushcclosure(s, [](lua_State* s)->int { auto _Ref = (xtable::reftype*)lua_touserdata(s, 1); auto& _Mtx = _Ref->mtx(); _Mtx.lock(); auto t = _Ref->ref(); if (!t) { _Mtx.unlock(); return luaL_error(s, "xshare table __newindex: 共享数据表引用已失效!"); } auto it = t->end(); int _Type = lua_type(s, 2); if (lua_gettop(s) > 1 && _Type != LUA_TNIL) { if (_islxkey(_Type)) it = t->find(_lxkey(s, 2)); } if (it != t->end()) ++it; else it = t->begin(); if (it == t->end()) { _Mtx.unlock(); return 0; } xtable::put_key(s, it->first); xtable::put_val(s, it->second); _Mtx.unlock(); return 2; }, 1); lua_pushvalue(s, 1); lua_pushnil(s); return 3; } // xshare.new(name) 创建根共享表 static int xshare_new(lua_State* s) { xRoot.rs->mtx.lock(); if (!lua_gettop(s)) { xRoot.rs->mtx.unlock(); return luaL_error(s, "xshare.new 需要一个有效的string索引值"); } if (lua_type(s, 1) != LUA_TSTRING) { xRoot.rs->mtx.unlock(); return luaL_error(s, "xshare.new 需要一个有效的string索引值"); } xRoot.new_table(s, lua_tostring(s, 1)); xRoot.rs->mtx.unlock(); return 1; } static bool _isxtab(lua_State* s, int n) { if (lua_type(s, n) != LUA_TUSERDATA) return false; lua_getmetatable(s, n); bool _Result = (lua_topointer(s, -1) == lua_topointer(s, lua_upvalueindex(1))); lua_pop(s, 1); return _Result; } // xshare.pcall(xshare_table) 基本用法等同于pcall static int xshare_pcall(lua_State* s) { if (lua_gettop(s) < 2) return luaL_error(s, "xshare.pcall 参数错误:请参考:xshare.pcall(xshare_table, function [, args])"); if (!_isxtab(s, 1)) return luaL_error(s, "xshare.pcall 参数错误:请参考:xshare.pcall(xshare_table, function [, args])"); if (lua_type(s, 2) != LUA_TFUNCTION) return luaL_error(s, "xshare.pcall 参数错误:请参考:xshare.pcall(xshare_table, function [, args])"); auto _Ref = (xtable::reftype*)lua_touserdata(s, 1); auto& _Mtx = _Ref->mtx(); _Mtx.lock(); int _Top = lua_gettop(s); int _Argc = _Top - 2; lua_pushvalue(s, 2); for (int i = 1; i <= _Argc; i++) lua_pushvalue(s, _Argc + i); if (lua_pcall(s, _Argc, LUA_MULTRET, 0)) { _Mtx.unlock(); lua_pushboolean(s, false); lua_insert(s, -2); return 2; } _Mtx.unlock(); lua_pushboolean(s, true); int _Resultc = lua_gettop(s) - _Top; if (_Resultc > 0) lua_insert(s, -(_Resultc)); return _Resultc; } // xshare.istab(xshare_table) 判断一个变量是不是一个共享数据表 static int xshare_istab(lua_State* s) { if (lua_gettop(s) < 1) { lua_pushboolean(s, false); return 1; } lua_pushboolean(s, _isxtab(s, 1)); return 1; } // xshare.islife(xshare_table) 判断一个共享数据表是否还有效 static int xshare_islife(lua_State* s) { if (lua_gettop(s) < 1) { lua_pushboolean(s, false); return 1; } if (!_isxtab(s, 1)) { lua_pushboolean(s, false); return 1; } auto _Ref = (xtable::reftype*)lua_touserdata(s, 1); auto& _Mtx = _Ref->mtx(); _Mtx.lock(); bool _Result = (_Ref->ref() != nullptr); _Mtx.unlock(); lua_pushboolean(s, _Result); return 1; } // xshare.swap(xshare_table[,table]) 可与lua table进行数据交换 static int xshare_swap(lua_State* s) { int _Top = lua_gettop(s); if (_Top < 1) return luaL_error(s, "xshare.swap 参数错误:请参考:xshare.swap(xshare_table[,table])"); if (!_isxtab(s, 1)) return luaL_error(s, "xshare.swap 参数错误:请参考:xshare.swap(xshare_table[,table])"); auto _Ref = (xtable::reftype*)lua_touserdata(s, 1); auto& _Mtx = _Ref->mtx(); _Mtx.lock(); auto t = _Ref->ref(); if (!t) { _Mtx.unlock(); return luaL_error(s, "xshareswap: 共享数据表引用已失效!"); } t->toluatable(s); if (_Top > 1) { if (lua_istable(s, 2)) { int rc = t->swap_tab(s, 2); _Mtx.unlock(); if (rc == -1) return luaL_error(s, "xshare table __newindex: 字段中存在无效的索引类型"); else if (rc == -2) return luaL_error(s, "xshare table __newindex: 字段中存在无效的共享类型"); else if (rc == -3) return luaL_error(s, "xshare table __newindex: 无效的共享类型(支持的类型为 boolean number string table lightuserdata)"); } else { _Mtx.unlock(); return luaL_error(s, "xshare.swap(xshare_table, table) 参数2必须是一个lua table"); } } else { _Mtx.unlock(); } return 1; } // xshare.clear(xshare_table) 清空一个共享数据表 static int xshare_clear(lua_State* s) { int _Top = lua_gettop(s); if (_Top < 1) return luaL_error(s, "xshare.clear 参数错误:请参考:xshare.clear(xshare_table)"); if (!_isxtab(s, 1)) return luaL_error(s, "xshare.clear 参数错误:请参考:xshare.clear(xshare_table)"); auto _Ref = (xtable::reftype*)lua_touserdata(s, 1); auto& _Mtx = _Ref->mtx(); _Mtx.lock(); auto t = _Ref->ref(); if (!t) { _Mtx.unlock(); return luaL_error(s, "xshare.clear: 共享数据表引用已失效!"); } t->clear(); _Mtx.unlock(); return 0; } static int xshare_mutex(lua_State* s) { if (lua_gettop(s) < 2) return luaL_error(s, "xshare.mutex 参数错误:请参考:xshare.mutex(xshare_table, function)"); if (!_isxtab(s, 1)) return luaL_error(s, "xshare.mutex 参数错误:请参考:xshare.mutex(xshare_table, function)"); if (lua_type(s, 2) != LUA_TFUNCTION) return luaL_error(s, "xshare.mutex 参数错误:请参考:xshare.mutex(xshare_table, function)"); lua_pushvalue(s, 1); lua_pushvalue(s, 2); lua_pushcclosure(s, [](lua_State* s)->int { auto _Ref = (xtable::reftype*)lua_touserdata(s, lua_upvalueindex(1)); auto& _Mtx = _Ref->mtx(); _Mtx.lock(); lua_pushvalue(s, lua_upvalueindex(2)); int _Top = lua_gettop(s); for (int i = 1; i <= _Top; i++) lua_pushvalue(s, i); if (lua_pcall(s, _Top, LUA_MULTRET, 0)) { _Mtx.unlock(); return lua_error(s); } _Mtx.unlock(); return lua_gettop(s) - _Top; }, 2); return 1; } } static int luaL_openxsharelib(lua_State* s) { lua_getglobal(s, "xshare"); if (lua_istable(s, -1)) { lua_pop(s, 1); return 0; } lua_pop(s, 1); luaL_Reg funcs[] = { {"new",lxshare_internal::xshare_new}, {"pcall", lxshare_internal::xshare_pcall }, {"istab", lxshare_internal::xshare_istab }, {"islife", lxshare_internal::xshare_islife }, {"swap", lxshare_internal::xshare_swap }, {"clear", lxshare_internal::xshare_clear}, {"mutex", lxshare_internal::xshare_mutex}, {NULL,NULL}, }; luaL_newlibtable(s, funcs); luaL_Reg metatab_funcs[] = { { "__gc", lxshare_internal::xtable_gc }, { "__index", lxshare_internal::xtable_index }, { "__newindex", lxshare_internal::xtable_newindex }, { "__len", lxshare_internal::xtable_len }, { "__pairs", lxshare_internal::xtable_pairs }, {NULL,NULL}, }; luaL_newlibtable(s, metatab_funcs); lua_pushvalue(s, -1); luaL_setfuncs(s, metatab_funcs, 1); luaL_setfuncs(s, funcs, 1); lua_setglobal(s, "xshare"); return 0; }
简单的测试代码：
C++:
#include <iostream> #include "lua.hpp" #pragma comment(lib, "lua54.lib") #include "lxsharelib.hpp" void test_lxsharelib(int thread_index) { lua_State* s = luaL_newstate(); luaL_openlibs(s); lua_openxsharelib(s); int rc = luaL_dofile(s, "xshare.lua"); if (rc) { printf("%s\n", lua_tostring(s, -1)); return; } lua_pushinteger(s, thread_index); lua_setglobal(s, "thread_index"); lua_getglobal(s, "Foo1"); int fn = luaL_ref(s, LUA_REGISTRYINDEX); for (int i = 0; i < 5; i++) { lua_rawgeti(s, LUA_REGISTRYINDEX, fn); lua_call(s, 0, 0); } luaL_unref(s, LUA_REGISTRYINDEX, fn); lua_close(s); } int main() { for (int i = 0; i < 3; i++) std::thread(test_lxsharelib, i).detach(); system("pause"); return 0; }
lua:
-- xshare.lua -- xshare.new(name) 创建一个共享数据表 local xst = xshare.new('test share table') -- xshare.pcall 与 lua 的 pcall 行为完全一致，但在调用之前会使用xst中的锁对象加锁 xshare.pcall(xst, function () if xst.a == nil then xst.a = 1; end end); -- xshare.mutex(xst, function) 会返回一个函数，函数调用时加锁， -- 它不是pcall的机制，不会返回是否调用成功和错误信息，一旦调用过程有错误，它会解锁，报错。 Foo1 = xshare.mutex(xst, function() print("(thread" .. tostring(thread_index) .. "):" .. tostring(xst.a)); xst.a = xst.a + 1; end); -- 这个测试脚本代码，预期的输出: --(threadx):y --x从0到2，共3个线程 --y从1到15，每个线程调用5次Foo1 --y会按照顺序输出
