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++时，可以在命令行中直接设置。

 

//lxsharelib.h
#pragma once
#include "lua/lua.hpp"

/*
lua_openxsharelib 向一个lua_State中提供一个名为：xshare的table
提供以下接口：
xshare.new(key); -- 返回一个和key关联的共享table副本，如果指定的key是已存在的共享table，则引用它，否则就创建它。key类型可以是整数，浮点数，字符串

xshare.lock(xshare_table); -- 锁定共享table
xshare.unlock(xshare_table); -- 解锁共享table
xshare.mutex(xshare_table, func); --func是回调函数，也就是一种自动加解锁的模式，用来应对那种可能在函数中很多地方需要返回的加解锁处理的方案
示例：
xshare.mutex(xst, function(_Tab)
    for i, e in pairs(_Tab) do
        print(i..':'..e);
    end
end);


local ret = xshare.get(xshare_table); -- 将当前共享表的内容完整的复制到lua中，注意ret是一个正常table
示例：
local xt = xshare.new('test share table');
xt.d = {1,2,3};
local tab = xshare.get(xt);
local tab_d = xshare.get(xt.d);


xshare.set(xshare_table, table); -- 如果是要直接将根节点设置为一个表，可以使用这个方法，也就是它和xshare.get是反过来的作用
示例：
local xt = xshare.new('test share table');
xshare.set(xt, {d = {1,2,3}});


不能将一个xshare_table设置为nil，参数2：table必须是一个有效的table，可以是空表，但不能是nil，理由如下：
本来我已经写好了xshare.delete，最终我删掉了，原因是，由lua删除共享表根节点会把事情变得复杂，
因为根节点必定是所有线程一起保存在各自的文件中，其中某个线程删除了根节点，其他线程要解决错误就非常蛋疼了。
需要删除子节点可以使其=nil，而会被我们删除的子节点，本身就不应该由我们的来保存它的副本。
所以我仅仅考虑了在C++里释放内存的方式：lua_closexsharelib，当所有lua对象已经88的时候，由C++调用它即可释放内存
*/

int lua_openxsharelib(lua_State *s);
int lua_closexsharelib();

//lxsharelib.cpp
#include "pch.h"
#include 
#include <string>
#include 
#include 
#include "lxsharelib.h"

class xshare_table;
using xshare_bool = unsigned char;
using xshare_value = std::variantstring, intptr_t, double, xshare_bool, xshare_table*>;
using xshare_key = std::variantstring, intptr_t, double>;
using xshare_type = std::unordered_map;

class xshare_table {
public:
    xshare_table() {imax = 0;}
    ~xshare_table() {
        for (auto it = vars.begin(); it != vars.end(); ++it) {
            if (it->second.index() == 4) delete (std::get<4>(it->second));
        }
    }

    std::recursive_mutex mtx;
    intptr_t imax;
    xshare_type vars;
};

#define lua_isintnum(_Number_) (_Number_ - floor(_Number_) < 1e-6)


/*
 从lua栈上获取xshare_key
*/
int xshare_get_key(lua_State *s, int n, xshare_key &k) {

    int _Type = lua_type(s, n);
    switch (_Type) {
    case LUA_TNUMBER: {
        double dv = lua_tonumber(s, n);
        if (lua_isintnum(dv))//判断整数
            k = (intptr_t)dv;
        else
            k = dv;
        break;
    }
    case LUA_TSTRING:
        k = lua_tostring(s, n);
        break;
    default:
        // 莫名奇妙的key时，返回-1，让上层去报错
        return -1;
    }
    return 0;
}

/*
 从lua的栈上，获取xshare_table的指针
*/
xshare_table *xshare_ctab(lua_State *s) {
    if (!lua_gettop(s) || lua_type(s, 1) != LUA_TTABLE) {
        luaL_error(s, "invalid share_table");
        return nullptr;
    }

    lua_pushstring(s, "__ptr_");
    lua_gettable(s, 1);
    if (lua_type(s, -1) == LUA_TNIL) {
        // 获取 __ptr_失败时，报错
        lua_pop(s, 1);
        luaL_error(s, "invalid share_table");
        return nullptr;
    }
    xshare_table *_Result = (xshare_table *)lua_touserdata(s, -1);
    lua_pop(s, 1);
    return _Result;
}

/*
 将share_table中的key返回给lua的push环节
*/
void xshare_push_key(lua_State *s, const xshare_key &k) {
    switch (k.index()) {
    case 0://std::string
        lua_pushstring(s, std::get<0>(k).c_str());
        break;
    case 1://intptr_t
        lua_pushinteger(s, std::get<1>(k));
        break;
    case 2://double
        lua_pushnumber(s, std::get<2>(k));
        break;
    }
}


/*
 将share_table中的value返回给lua的push环节
*/
void xshare_push_val(lua_State *s, const xshare_value &v) {
    switch (v.index()) {
    case 0://std::string
        lua_pushstring(s, std::get<0>(v).c_str());
        break;
    case 1://intptr_t
        lua_pushinteger(s, std::get<1>(v));
        break;
    case 2://double
        lua_pushnumber(s, std::get<2>(v));
        break;
    case 3://xshare_bool(unsigned char)
        lua_pushboolean(s, std::get<3>(v));
        break;
    case 4://xshare_table*
        lua_newtable(s);
        lua_pushstring(s, "__ptr_");
        lua_pushlightuserdata(s, std::get<4>(v));
        lua_settable(s, -3);
        lua_getglobal(s, "__xshare_object_metatable");
        lua_setmetatable(s, -2);
        break;
    }
}

/*
 __index元方法
*/
int lua_xshare_get(lua_State *s) {
    auto p = xshare_ctab(s);
    xshare_key k;
    if(xshare_get_key(s, 2, k))
        luaL_error(s, "invalid xshare_key type:%s", lua_typename(s, lua_type(s, 2)));

    auto it = p->vars.find(k);
    if (it == p->vars.end())
        return 0;
    xshare_push_val(s, it->second);
    return 1;
}

int xshare_set_tab(lua_State *s, xshare_table *t, int n);

/*
 share_table.key = lua栈(n)
*/
int xshare_set_tabval(lua_State *s, xshare_table *t, xshare_key &key, int n) {

    auto it = t->vars.find(key);
    bool et = false;
    bool st = false;
    if (it != t->vars.end()) {
        if (it->second.index() == 4)
            st = true;
        et = true;
    }

    /*
     如果是由__newindex调用，LUA_TNIL已经在上层判断过了
     如果是由lua_next遍历table过来的调用，是不会获得nil的
     所以这里不需要判断nil类型
    */
    int _Type = lua_type(s, n);

    switch (_Type) {
    case LUA_TBOOLEAN:
        if (et) {
            //已存在的key
            if (st) delete (std::get<4>(it->second));//value是xshare_table时，删除它
            it->second = (xshare_bool)lua_toboolean(s, n);
        }
        else {
            
            t->vars[key] = (xshare_bool)lua_toboolean(s, n);
        }
        break;
    case LUA_TNUMBER: {
        double dv = lua_tonumber(s, n);
        if (et) {
            if (st) delete (std::get<4>(it->second));
            if (lua_isintnum(dv))
                it->second = (intptr_t)dv;
            else
                it->second = dv;
        }
        else
        {
            if (lua_isintnum(dv))
                t->vars[key] = (intptr_t)dv;
            else
                t->vars[key] = dv;
        }
        break;
    }
    case LUA_TSTRING: {
        if (et) {
            if (st) delete (std::get<4>(it->second));
            it->second = lua_tostring(s, n);
        }
        else {
            t->vars[key] = lua_tostring(s, n);
        }
        break;
    }
    case LUA_TTABLE: {
        xshare_table *_rt;
        if (et) {
            if (!st) {
                // 不是xshare_table时，预先创建它
                _rt = new xshare_table;
                it->second = _rt;
            }
            else {
                // 已经是xshare_table了，就直接返回它
                _rt = std::get<4>(it->second);
            }
        }
        else {
            _rt = new xshare_table;
            t->vars[key] = _rt;
        }
        
        return xshare_set_tab(s, _rt, ((n > 0) ? n : -2));//递归前进, n比0大时，直接传入n，否则直接传入-2（它包含了lua_pushnil，所以是-2）
        break;
    }
    default:
        return -1;
    }

    return 0;
}

int xshare_set_tab(lua_State *s, xshare_table *t, int n) {
    lua_pushnil(s);
    int _Result = 0;
    while (lua_next(s, n)) {
        xshare_key key;
        if (xshare_get_key(s, -2, key)) {
            //获取key错误时，清理栈并返回错误信息
            _Result = (1 << 16) | lua_type(s, -2);
            lua_pop(s, 1);
            break;
        }

        if (key.index() == 1) {
            //整数key时，记录最大index
            intptr_t i = std::get<1>(key);
            if (i > t->imax)
                t->imax = i;
        }


        int rc = xshare_set_tabval(s, t, key, -1);

        // 由此处判断rc的理由是，在产生错误之后，让最上层的调用处去报告错误，这样就能在出错之后最起码保证lua栈还是正确的
        if (rc == -1) {
            //设置数据错误时，如果返回值为-1，说明错误在当前这一层table里，此时应该清理栈并返回错误信息
            _Result = (2 << 16) | lua_type(s, -2);
            lua_pop(s, 1);
            break;
        }
        else {
            //如果返回值不为0，说明错误在由更下层的table返回，此时应该直接清理栈并返回rc
            if (rc != 0) {
                _Result = rc;
                lua_pop(s, 1);
                break;
            }
        }

        lua_pop(s, 1);
    }

    return 0;
}


/*
 __newindex元方法
*/
int lua_xshare_set(lua_State *s)
{
    auto p = xshare_ctab(s);
    xshare_key key;
    if(xshare_get_key(s, 2, key))
        luaL_error(s, "invalid xshare_key type:%s", lua_typename(s, lua_type(s, 2)));

    int vt = lua_type(s, 3);
    auto it = p->vars.find(key);
    if (it != p->vars.end()) {
        if (key.index() == 1) {
            intptr_t ikey = std::get<1>(it->first);
            if (vt == LUA_TNIL) {
                // 删除了最大的一个整数key时，让imax-1
                if (p->imax == ikey)
                    p->imax--;

                if (it->second.index() == 4) //如果被设置为nil的对象是一个xshare_table，删除它
                    delete (std::get<4>(it->second));
                p->vars.erase(it);
                return 0;
            }

            //被设置的ikey比imax更大时，更改记录
            if (ikey > p->imax)
                p->imax = ikey;
        }
        else
        {
            if (vt == LUA_TNIL) {
                if (it->second.index() == 4) //如果被设置为nil的对象是一个xshare_table，删除它
                    delete (std::get<4>(it->second));
                p->vars.erase(it);
                return 0;
            }
        }
    }
    else
    {
        // 当key不存在时，如果value是nil，直接返回
        // lua本身这个样子操作好像是要报错的，但这个报错我感觉意义并不大，也许这仅仅是我的感觉，如果要让它报错，删掉这个判断即可
        if (vt == LUA_TNIL) return 0;
        if (key.index() == 1) {
            intptr_t ikey = std::get<1>(key);
            if (ikey > p->imax)
                p->imax = ikey;
        }
    }

    int rc = xshare_set_tabval(s, p, key, 3);
    if (rc == -1) {
        luaL_error(s, "invalid xshare value type:%s", lua_typename(s, lua_type(s, 3)));
    }
    else {
        if (rc != 0) {
            luaL_error(s, 
                (((((unsigned int)rc) >> 16) & 0xFFFF) == 1) ? "invalid xshare_key type:%s" : "invalid xshare value type:%s", 
                lua_typename(s, (((unsigned int)rc) & 0xFFFF)));
        }
    }
    return 0;
}

/*
 给迭代器返回的next函数
*/
int lua_xshare_next(lua_State *s) {
    auto p = xshare_ctab(s);
    auto it = p->vars.end();
    
    if (lua_gettop(s) > 1 && lua_type(s, 2) != LUA_TNIL) {
        xshare_key key;
        if(xshare_get_key(s, 2, key))
            luaL_error(s, "invalid xshare_key type:%s", lua_typename(s, lua_type(s, 2)));
        it = p->vars.find(key);
    }

    if (it != p->vars.end()) 
        ++it;
    else
        it = p->vars.begin();
    
    if (it == p->vars.end())
        return 0;
    xshare_push_key(s, it->first);
    xshare_push_val(s, it->second);
    return 2;
}

/*
 __len元方法，也就是#tab
*/
int lua_xshart_getn(lua_State *s) {
    auto p = xshare_ctab(s);
    intptr_t j = p->imax;
    if (j > 0) {
        auto it = p->vars.find(j);
        if (it != p->vars.end())
        {
            lua_pushinteger(s, j);
            return 1;
        }

        //这一段二叉查找整数key边界，我是直接从lua5.3中的ltable.c中luaH_getn里抄过来的，
        //在5.4中它又有了新的变化，预先存在了一系列路径判断，尽可能的考虑不去用哈希表搜索，但最坏的情况还是存在这段代码，在binsearch函数中
        intptr_t i = 0;
        while (j - i > 1) {
            intptr_t m = (i + j) >> 1;
            if (p->vars.find(m) == p->vars.end())
                j = m;
            else
                i = m;
        }

        p->imax = i;
        lua_pushinteger(s, i);
        return 1;
    }
    lua_pushinteger(s, 0);
    return 1;
}

/*
 __pairs元方法
*/
int lua_xshare_pairs(lua_State *s)
{
    /*
      自定义pairs元方法的知识点，很少有人提及这个东西，我在这里顺带说一下：
        lua中的 for key, e in pairs(t) do ... end 是一串语法糖
        -- 实际上它等同于下面这样子
        local t, next, key = pairs(t);--第一个key必定是nil，就像我们在C里面lua_pushnil(s); while(lua_next(s, n))...一样
        while 1 do
            key, e = next(t, key);
            if key == nil then break; end--由next返回了key为nil，就说明结束了
            ...
        end
    */

    lua_pushcfunction(s, lua_xshare_next);
    lua_pushvalue(s, 1);
    lua_pushnil(s);
    return 3;
}

//所有共享数据都存在这里
xshare_table xtabs;


int lua_xshare_new(lua_State *s) {
    std::lock_guard lg(xtabs.mtx);
    if (!lua_gettop(s)) 
        return 0;
    xshare_key key;
    if (xshare_get_key(s, 1, key))
        return 0;
    xshare_table *_Result = nullptr;
    auto it = xtabs.vars.find(key);
    if (it != xtabs.vars.end())
        _Result = std::get<4>(it->second);
    else {
        _Result = new xshare_table;
        xtabs.vars[key] = _Result;
    }

    lua_newtable(s);
    lua_pushstring(s, "__ptr_");
    lua_pushlightuserdata(s, _Result);
    lua_settable(s, -3);
    lua_getglobal(s, "__xshare_object_metatable");
    lua_setmetatable(s, -2);
    return 1;
}

int lua_xshare_lock(lua_State *s) {
    xshare_table *p = xshare_ctab(s);
    p->mtx.lock();
    return 0;
}

int lua_xshare_unlock(lua_State *s) {
    xshare_table *p = xshare_ctab(s);
    p->mtx.unlock();
    return 0;
}

int lua_xshare_mutex(lua_State *s) {
    xshare_table *p = xshare_ctab(s);
    p->mtx.lock();
    if (lua_gettop(s) < 2 && lua_type(s, 2) != LUA_TFUNCTION) {
        // 如果是调用xshare.mutex本身的参数错误了，那么就应该先解锁，然后报错
        // 因为luaL_error会longjmp到上一个lua_pcall里
        p->mtx.unlock();
        luaL_error(s, "xshare.mutex args error, should xshare.mutex(share_table, func)");
        return 0;
    }

    lua_pushvalue(s, 2);
    lua_pushvalue(s, 1);
    if (lua_pcall(s, 1, 1, 0)) {
        printf("xshare_mutex->lua_pcall error:%s\n", lua_tostring(s, -1));
        lua_pop(s, 1);//pcall错误时，先输出错误信息，然后将栈弹出
        p->mtx.unlock();
        return 0;
    }

    p->mtx.unlock();
    //正常完成之后，返回一个回调函数的返回值
    return 1;
}

void xshare_completeget_push(lua_State *s, xshare_table *p) {
    for (auto it = p->vars.begin(); it != p->vars.end(); ++it) {
        xshare_push_key(s, it->first);
        auto &v = it->second;
        switch (v.index()) {
        case 0://std::string
            lua_pushstring(s, std::get<0>(v).c_str());
            break;
        case 1://intptr_t
            lua_pushinteger(s, std::get<1>(v));
            break;
        case 2://double
            lua_pushnumber(s, std::get<2>(v));
            break;
        case 3://xshare_bool(unsigned char)
            lua_pushboolean(s, std::get<3>(v));
            break;
        case 4://xshare_table*
            lua_newtable(s);
            xshare_completeget_push(s, std::get<4>(v));
            break;
        }
        lua_settable(s, -3);
    }
}

int lua_xshare_completeget(lua_State *s) {
    xshare_table *p = xshare_ctab(s);
    lua_newtable(s);
    xshare_completeget_push(s, p);
    return 1;
}


int lua_xshare_completeset(lua_State *s) {
    xshare_table *p = xshare_ctab(s);
    if (lua_gettop(s) < 2 || lua_type(s, 2) != LUA_TTABLE) 
        luaL_error(s, "xshare.set args error, should xshare.set(share_table, table)");

    for (auto it = p->vars.begin(); it != p->vars.end(); ++it) {
        if (it->second.index() == 4)
            delete (std::get<4>(it->second));
    }
    p->vars.clear();
    xshare_set_tab(s, p, 2);
    return 0;
}

int lua_openxsharelib(lua_State *s) {
    lua_newtable(s);
    lua_pushcfunction(s, lua_xshare_get);
    lua_setfield(s, -2, "__index");

    lua_pushcfunction(s, lua_xshare_set);
    lua_setfield(s, -2, "__newindex");

    lua_pushcfunction(s, lua_xshare_pairs);
    lua_setfield(s, -2, "__pairs");

    lua_pushcfunction(s, lua_xshart_getn);
    lua_setfield(s, -2, "__len");

    lua_setglobal(s, "__xshare_object_metatable");


    lua_newtable(s);

    lua_pushcfunction(s, lua_xshare_new);
    lua_setfield(s, -2, "new");

    lua_pushcfunction(s, lua_xshare_lock);
    lua_setfield(s, -2, "lock");

    lua_pushcfunction(s, lua_xshare_unlock);
    lua_setfield(s, -2, "unlock");

    lua_pushcfunction(s, lua_xshare_mutex);
    lua_setfield(s, -2, "mutex");

    lua_pushcfunction(s, lua_xshare_completeget);
    lua_setfield(s, -2, "get");

    lua_pushcfunction(s, lua_xshare_completeset);
    lua_setfield(s, -2, "set");
    
    lua_setglobal(s, "xshare");

    return 0;
}

int lua_closexsharelib() {
    std::lock_guard lg(xtabs.mtx);
    for (auto it = xtabs.vars.begin(); it != xtabs.vars.end(); ++it) {
        if (it->second.index() == 4)
            delete (std::get<4>(it->second));
    }
    xtabs.vars.clear();
}

 

 

// ConsoleApplication4.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include "pch.h"
#include 
#include 
#pragma comment(lib, "lua54.lib")
#include "lxsharelib.h"
int main(int argc, char **argv)
{

    auto t1 = std::thread([]() {
        lua_State *s1 = luaL_newstate();
        luaL_openlibs(s1);
        lua_openxsharelib(s1);
        if (luaL_dofile(s1, "G:\\vs2017\\ConsoleApplication2\\x64\\Release\\script\\xshare.lua"))
            printf("%s\n", lua_tostring(s1, -1));
        lua_close(s1);
    });

    //这里的sleep，是为了让上面那个线程先跑一会儿,因为本例中对共享table的数据写入，是由它完成的。。
    std::this_thread::sleep_for(std::chrono::microseconds(10));
    
    //下边这个线程只是测试输出一下，具体可以看lua代码
    auto t2 = std::thread([]() {
        lua_State *s2 = luaL_newstate();
        luaL_openlibs(s2);
        lua_openxsharelib(s2);
        luaL_dofile(s2, "G:\\vs2017\\ConsoleApplication2\\x64\\Release\\script\\xshare2.lua");
        lua_close(s2);
    });

    t1.join();
    t2.join();

    return 0;
}

 

测试脚本代码：

-- xshare.lua
-- print附近的注释为预测输出的内容
local xt = xshare.new('test share table')


xshare.lock(xt);
print('******************s1******************');
xt.a = 'text';
print(xt.a);--text
xt.b = 111222333;
print(xt.b);--1122333
xt.c = true;
print(xt.c)--true
xt.c = false;
print(xt.c)--false

xt.d = {1,2,3};

--[[
    预期的输出：
    1
    2
    3
]]
for i, e in ipairs(xt.d) do
    print(e);
end


xt.d[4] = 4;

--[[
    预期的输出：
    1
    2
    3
    4
]]
for i, e in ipairs(xt.d) do
    print(e);
end

xt.e = {aa='1t', bb=2, cc=true};

--[[
    
    要注意：hash表遍历是不能保证顺序的
    预期的输出：
    aa  1t
    bb  2
    cc  true
]]
for i, e in pairs(xt.e) do
    print(i, e)
end


xt.f = {[11]=11,1,2,3,nil,5,6,7,8,9,10,x=12};

print(#(xt.f))-- 11
xt.f[10] = nil;
print(#(xt.f))-- 11
xt.f[11] = nil;
print(#(xt.f))-- 9
xt.f[9] = nil;
print(#(xt.f));-- 8


--[[
预期的输出：
1:1
x:12
2:2
3:3
5:5
6:6
7:7
8:8
]]
xshare.mutex(xt.f, function(_Tab)
    for i, e in pairs(_Tab) do
        print(i..':'..e);
    end
end);


-- 使用xshare.mutex主要的目的是避免死锁问题
-- 下面我们来实现一个错误
xshare.mutex(xt, function(_Tab)
    _Tab.g = function() print(1) end;
end);


-- 报错之后，继续执行

xshare.mutex(xt, function(_Tab)

    print('test get set');
    -- 完整获取原来的table
    local old = xshare.get(_Tab);
    
    -- 将它设置为一个新的table
    xshare.set(_Tab, {x = 1, y = 2, z = 3});

    --[[
        预测的输出：
        x:1
        y:2
        z:3
    ]]
    for i, e in pairs(_Tab) do
        print(i..':'..e);
    end

    -- 还原它
    xshare.set(_Tab, old);
end)


xshare.unlock(xt);

 

 

-- xshare2.lua
-- print附近的注释为预测输出的内容
local xt = xshare.new('test share table')


xshare.lock(xt);
print('******************s2******************');
print(xt.a);--text

print(xt.b);--1122333

print(xt.c)--true


--[[
    1
    2
    3
    4
]]
for i, e in ipairs(xt.d) do
    print(e);
end

--[[
    要注意：hash表遍历是不能保证顺序的

    aa  1t
    bb  2
    cc  true
]]
for i, e in pairs(xt.e) do
    print(i, e)
end
xshare.unlock(xt);

 

******************s1******************

text

111222333

true

false

1

2

3

1

2

3

4

bb      2

cc      true

aa      1t

11

11

9

8

1:1

x:12

2:2

3:3

5:5

6:6

7:7

8:8

xshare_mutex->lua_pcall error:G:\vs2017\ConsoleApplication2\x64\Release\script\xshare.lua:90: invalid xshare value type:function

test get set

x:1

z:3

y:2

******************s2******************

text

111222333

false

1

2

3

4

bb      2

cc      true

aa      1t