refactor & feat: Environment添加互斥锁

include/core/inter.h

@@ -1,6 +1,7 @@
 #ifndef AFUN_INTER_H
 #define AFUN_INTER_H
 #include <list>
+#include <mutex>
 #include "aFuntool.h"
 #include "aFunCoreExport.h"
 
@@ -37,13 +38,14 @@ namespace aFuncore {
         Object *obj;
         Var *var;
         VarSpace *varspace;
+        size_t reference;  // 引用计数
+        bool destruct;
+        std::mutex lock;
 
-        ProtectVarSpace *protect;  // 保护变量空间
-        VarSpace *global;  // 全局变量空间
-        VarList *global_varlist;  // global + protect
+        ProtectVarSpace *const protect;  // 保护变量空间
+        VarSpace *const global;  // 全局变量空间
+        VarList *const global_varlist;  // global + protect
         EnvVarSpace envvar;
-
-        size_t reference;  // 引用计数
     };
 
     class AFUN_CORE_EXPORT Inter {

include/core/inter.inline.h

@@ -52,18 +52,22 @@ namespace aFuncore {
     }
 
     inline size_t Environment::operator++(){
+        std::unique_lock<std::mutex> mutex{lock};
         return ++reference;
     }
 
     inline size_t Environment::operator--(){
+        std::unique_lock<std::mutex> mutex{lock};
         return --reference;
     }
 
     inline size_t Environment::operator++(int){
+        std::unique_lock<std::mutex> mutex{lock};
         return reference++;
     }
 
     inline size_t Environment::operator--(int){
+        std::unique_lock<std::mutex> mutex{lock};
         return reference--;
     }
 

src/core/inter.cpp

@@ -167,24 +167,19 @@ namespace aFuncore {
         return true;
     }
 
-    Environment::Environment() : envvar{}{
-        obj = nullptr;
-        var = nullptr;
-        varspace = nullptr;
-
-        protect = new ProtectVarSpace(*this);  // 放到最后
-        global = new VarSpace(*this);  // 放到最后
-        global_varlist = new VarList(protect);
+    Environment::Environment()
+        : obj{nullptr}, var{nullptr}, varspace{nullptr},
+          protect{new ProtectVarSpace(*this)}, global{new VarSpace(*this)},
+          global_varlist{new VarList(protect)}, destruct{false} {
         global_varlist->push(global);
-
         reference = 0;
     }
 
-    Environment::~Environment() noexcept(false){
+    Environment::~Environment() noexcept(false) {
         if (reference != 0)
             throw EnvironmentDestructException();
 
-        if (global_varlist == nullptr)
+        if (destruct)
             return;
 
         delete global_varlist;
@@ -196,9 +191,6 @@ namespace aFuncore {
         obj = nullptr;
         var = nullptr;
         varspace = nullptr;
-
-        protect = nullptr;  // 放到最后
-        global = nullptr;  // 放到最后
-        global_varlist = nullptr;
+        destruct = true;
     }
 }

src/core/value.cpp

@@ -4,11 +4,13 @@
 namespace aFuncore {
     Object::Object(std::string type_, Inter &inter)
             : type{std::move(type_)}, env{inter.getEnvironment()}{
+        std::unique_lock<std::mutex> mutex{env.lock};
         this->addObject(env.obj);
     }
 
     Object::Object(std::string type_, Environment &env_)
             : type{std::move(type_)}, env{env_}{
+        std::unique_lock<std::mutex> mutex{env.lock};
         this->addObject(env.obj);
     }
 }

src/core/var.cpp

@@ -3,18 +3,22 @@
 
 namespace aFuncore {
     Var::Var(Object *data_, Inter &inter) : data{data_}, env{inter.getEnvironment()}{
+        std::unique_lock<std::mutex> mutex{env.lock};
         addObject(env.var);
     }
     
     Var::Var(Object *data_, Environment &env_) : data{data_}, env{env_}{
+        std::unique_lock<std::mutex> mutex{env.lock};
         addObject(env.var);
     }
     
     VarSpace::VarSpace(Inter &inter) : env{inter.getEnvironment()}{
+        std::unique_lock<std::mutex> mutex{env.lock};
         addObject(env.varspace);
     }
     
     VarSpace::VarSpace(Environment &env_) : env{env_}{
+        std::unique_lock<std::mutex> mutex{env.lock};
         addObject(env.varspace);
     }