react-native-update 10.34.2 → 10.34.4

package/harmony/pushy/src/main/cpp/HDiffPatch/libParallel/parallel_channel.cpp

@@ -0,0 +1,174 @@
+//  parallel_channel.cpp
+/*
+ The MIT License (MIT)
+ Copyright (c) 2018 HouSisong
+ 
+ Permission is hereby granted, free of charge, to any person
+ obtaining a copy of this software and associated documentation
+ files (the "Software"), to deal in the Software without
+ restriction, including without limitation the rights to use,
+ copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the
+ Software is furnished to do so, subject to the following
+ conditions:
+ 
+ The above copyright notice and this permission notice shall be
+ included in all copies of the Software.
+ 
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ OTHER DEALINGS IN THE SOFTWARE.
+ */
+#include "parallel_channel.h"
+
+#if (_IS_USED_MULTITHREAD)
+#include <assert.h>
+#include <deque>
+
+class _CChannel_import{
+public:
+    explicit _CChannel_import(ptrdiff_t maxDataCount)
+    :_locker(0),_sendCond(0),_acceptCond(0),
+    _maxDataCount(maxDataCount),_waitingCount(0),_isClosed(false){
+        _locker=locker_new();
+        _sendCond=condvar_new();
+        _acceptCond=condvar_new();
+    }
+    ~_CChannel_import(){
+        close();
+        while (true) { //wait all thread exit
+            if (_waitingCount==0) break;
+            {
+                CAutoLocker locker(_locker);
+                if (_waitingCount==0) break;
+            }
+            this_thread_yield(); //todo:优化?
+        }
+        locker_delete(_locker);
+        assert(_dataList.empty()); // why? if saved resource then leaks
+        condvar_delete(_acceptCond);
+        condvar_delete(_sendCond);
+    }
+    void close(){
+        if (_isClosed) return;
+        {
+            CAutoLocker locker(_locker);
+            if (_isClosed) return;
+            _isClosed=true;
+            condvar_broadcast(_sendCond);
+            condvar_broadcast(_acceptCond);
+        }
+    }
+    bool is_can_fast_send(bool isWait){
+        if (_maxDataCount<0) return true;
+        if (_maxDataCount==0) return false;
+        if (_isClosed) return false;
+
+        CAutoLocker locker(_locker);
+        while (true) {
+            if (_isClosed) return false;
+            if (_dataList.size()<(size_t)_maxDataCount) {
+                return true;
+            }else if(!isWait){
+                return false;
+            }//else wait
+            ++_waitingCount;
+            condvar_wait(_sendCond,&locker);
+            --_waitingCount;
+        }
+    }
+
+    bool send(TChanData data,bool isWait){
+        assert(data!=0);
+        if (_isClosed) return false;
+        {
+            CAutoLocker locker(_locker);
+            while (true) {
+                if (_isClosed) return false;
+                if ((_maxDataCount<=0)||(_dataList.size()<(size_t)_maxDataCount)) {
+                    try{
+                        _dataList.push_back(data);
+                    }catch(...){
+                        return false;
+                    }
+                    condvar_signal(_acceptCond);
+                    if (_maxDataCount==0) //must wait accepted?
+                        break;// to wait accepted
+                    else
+                        return true; //ok
+                }else if(!isWait){
+                    return false;
+                }//else wait
+                ++_waitingCount;
+                condvar_wait(_sendCond,&locker);
+                --_waitingCount;
+            }
+        }
+
+        //wait accepted
+        while (true) { //wait _dataList empty
+            if (_isClosed) break;
+            {
+                CAutoLocker locker(_locker);
+                if (_isClosed) break;
+                if (_dataList.empty()) break;
+            }
+            this_thread_yield(); //todo:优化;
+        }
+        return true;
+    }
+    TChanData accept(bool isWait){
+        CAutoLocker locker(_locker);
+        while (true) {
+            if (!_dataList.empty()) {
+                TChanData result=_dataList.front();
+                _dataList.pop_front();
+                if (!_isClosed)
+                    condvar_signal(_sendCond);
+                return result; //ok
+            }else if(_isClosed){
+                return 0;
+            }else if(!isWait){
+                return 0;
+            }//else wait
+            ++_waitingCount;
+            condvar_wait(_acceptCond,&locker);
+            --_waitingCount;
+        }
+    }
+private:
+    HLocker     _locker;
+    HCondvar    _sendCond;
+    HCondvar    _acceptCond;
+    std::deque<TChanData>   _dataList;
+    const ptrdiff_t         _maxDataCount;
+    volatile size_t         _waitingCount;
+    volatile bool           _isClosed;
+};
+
+
+CChannel::CChannel(ptrdiff_t maxDataCount):_import(0){
+    _import=new _CChannel_import(maxDataCount);
+}
+CChannel::~CChannel(){
+    delete (_CChannel_import*)_import;
+}
+void CChannel::close(){
+    _import->close();
+}
+bool CChannel::is_can_fast_send(bool isWait){
+    return _import->is_can_fast_send(isWait);
+}
+bool CChannel::send(TChanData data,bool isWait){
+    return _import->send(data,isWait);
+}
+TChanData CChannel::accept(bool isWait){
+    return _import->accept(isWait);
+}
+
+#endif //_IS_USED_MULTITHREAD

package/harmony/pushy/src/main/cpp/HDiffPatch/libParallel/parallel_channel.h

@@ -0,0 +1,73 @@
+//  parallel_channel.h
+/*
+ The MIT License (MIT)
+ Copyright (c) 2018 HouSisong
+ 
+ Permission is hereby granted, free of charge, to any person
+ obtaining a copy of this software and associated documentation
+ files (the "Software"), to deal in the Software without
+ restriction, including without limitation the rights to use,
+ copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the
+ Software is furnished to do so, subject to the following
+ conditions:
+ 
+ The above copyright notice and this permission notice shall be
+ included in all copies of the Software.
+ 
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef parallel_channel_h
+#define parallel_channel_h
+#include "parallel_import.h"
+#if (_IS_USED_MULTITHREAD)
+
+#include <stddef.h> //for size_t ptrdiff_t
+
+struct CHLocker{
+    HLocker locker;
+    inline CHLocker():locker(0) { locker=locker_new(); }
+    inline ~CHLocker() { locker_delete(locker); }
+};
+
+#if (_IS_USED_CPP11THREAD)
+#   include <mutex>
+    struct CAutoLocker:public _TLockerBox_name {
+        inline CAutoLocker(HLocker _locker)
+            :_TLockerBox_name(*(std::mutex*)_locker){ }
+        inline ~CAutoLocker(){ }
+    };
+#else
+    struct CAutoLocker:public TLockerBox {
+        inline CAutoLocker(HLocker _locker){ locker=_locker; locker_enter(locker); }
+        inline ~CAutoLocker(){ locker_leave(locker); }
+    };
+#endif
+
+    //通道交互数据;
+    typedef void* TChanData;
+
+    class _CChannel_import;
+    //通道;
+    class CChannel{
+    public:
+        explicit CChannel(ptrdiff_t maxDataCount=-1);
+        ~CChannel();
+        void close();
+        bool is_can_fast_send(bool isWait); //mybe not need wait when send
+        bool send(TChanData data,bool isWait); //can't send null
+        TChanData accept(bool isWait); //result can null;
+    private:
+        _CChannel_import* _import;
+    };
+
+#endif //_IS_USED_MULTITHREAD
+#endif //parallel_channel_h

package/harmony/pushy/src/main/cpp/HDiffPatch/libParallel/parallel_import.cpp

@@ -0,0 +1,367 @@
+//  parallel_import.cpp
+/*
+ The MIT License (MIT)
+ Copyright (c) 2018 HouSisong
+ 
+ Permission is hereby granted, free of charge, to any person
+ obtaining a copy of this software and associated documentation
+ files (the "Software"), to deal in the Software without
+ restriction, including without limitation the rights to use,
+ copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the
+ Software is furnished to do so, subject to the following
+ conditions:
+ 
+ The above copyright notice and this permission notice shall be
+ included in all copies of the Software.
+ 
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ OTHER DEALINGS IN THE SOFTWARE.
+ */
+#include "parallel_import.h"
+#include <assert.h>
+
+#if (_IS_USED_PTHREAD)
+#   ifdef WIN32
+#       include "windows.h" //for Sleep
+#       //pragma comment(lib,"pthread.lib") //for static pthread lib
+#       //define PTW32_STATIC_LIB  //for static pthread lib
+#   endif
+#   include <pthread.h>
+#   ifdef __ANDROID__
+#       include <sched.h> // sched_yield()
+#   endif
+#endif
+#if (_IS_USED_CPP11THREAD)
+#   include <thread>
+#   include <mutex>
+#   include <condition_variable>
+#endif
+#if (_IS_USED_WIN32THREAD)
+#   include "windows.h"
+#   ifndef UNDER_CE
+#       include "process.h"
+#   endif
+#endif
+
+#if (_IS_USED_PTHREAD)
+#include <string.h> //for memset
+#include <stdlib.h>
+#include <stdexcept>
+#include <string>
+#include <stdio.h>
+
+static std::string _i2a(int ivalue){
+    const int kMaxNumCharSize =32;
+    std::string result;
+    result.resize(kMaxNumCharSize);
+#ifdef _MSC_VER
+    int len=sprintf_s(&result[0],kMaxNumCharSize,"%d",ivalue);
+#else
+    int len=sprintf(&result[0],"%d",ivalue);
+#endif
+    result.resize(len);
+    return result;
+}
+#define _check_pthread(result,func_name) { \
+    if (result!=0) throw std::runtime_error(func_name "() return "+_i2a(result)+" error!"); }
+
+HLocker locker_new(void){
+    pthread_mutex_t* self=new pthread_mutex_t();
+    int rt=pthread_mutex_init(self, 0);
+    if (rt!=0){
+        delete self;
+        _check_pthread(rt,"pthread_mutex_init");
+    }
+    return  self;
+}
+void locker_delete(HLocker locker){
+    if (locker!=0){
+        pthread_mutex_t* self=(pthread_mutex_t*)locker;
+        int rt=pthread_mutex_destroy(self);
+        delete self;
+        _check_pthread(rt,"pthread_mutex_destroy");
+    }
+}
+
+void locker_enter(HLocker locker){
+    pthread_mutex_t* self=(pthread_mutex_t*)locker;
+    int rt=pthread_mutex_lock(self);
+    _check_pthread(rt,"pthread_mutex_lock");
+}
+void locker_leave(HLocker locker){
+    pthread_mutex_t* self=(pthread_mutex_t*)locker;
+    int rt=pthread_mutex_unlock(self);
+    _check_pthread(rt,"pthread_mutex_unlock");
+}
+
+HCondvar condvar_new(void){
+    pthread_cond_t* self=new pthread_cond_t();
+    int rt=pthread_cond_init(self,0);
+    if (rt!=0){
+        delete self;
+        _check_pthread(rt,"pthread_cond_init");
+    }
+    return self;
+}
+void    condvar_delete(HCondvar cond){
+    if (cond){
+        pthread_cond_t* self=(pthread_cond_t*)cond;
+        int rt=pthread_cond_destroy(self);
+        delete self;
+        _check_pthread(rt,"pthread_cond_destroy");
+    }
+}
+void    condvar_wait(HCondvar cond,TLockerBox* lockerBox){
+    pthread_cond_t* self=(pthread_cond_t*)cond;
+    int rt=pthread_cond_wait(self,(pthread_mutex_t*)(lockerBox->locker));
+    _check_pthread(rt,"pthread_cond_wait");
+}
+void    condvar_signal(HCondvar cond){
+    pthread_cond_t* self=(pthread_cond_t*)cond;
+    int rt=pthread_cond_signal(self);
+    _check_pthread(rt,"pthread_cond_signal");
+}
+void    condvar_broadcast(HCondvar cond){
+    pthread_cond_t* self=(pthread_cond_t*)cond;
+    int rt=pthread_cond_broadcast(self);
+    _check_pthread(rt,"pthread_cond_broadcast");
+}
+
+void this_thread_yield(){
+#ifdef __APPLE__
+    pthread_yield_np();
+#else
+#   ifdef WIN32
+    Sleep(0);
+#   else
+#       ifdef __ANDROID__
+            sched_yield();
+#       else
+            pthread_yield();
+#       endif
+#   endif
+#endif
+}
+
+struct _TThreadData{
+    TThreadRunCallBackProc  threadProc;
+    int                     threadIndex;
+    void*                   workData;
+};
+static void* _pt_threadProc(void* _pt){
+    _TThreadData* pt=(_TThreadData*)_pt;
+    pt->threadProc(pt->threadIndex,pt->workData);
+    delete pt;
+    return 0;
+}
+
+void thread_parallel(int threadCount,TThreadRunCallBackProc threadProc,void* workData,
+                     int isUseThisThread,int threadIndexStart){
+    for (int i=0; i<threadCount; ++i) {
+        if ((i==threadCount-1)&&(isUseThisThread)){
+            threadProc(i+threadIndexStart,workData);
+        }else{
+            _TThreadData* pt=new _TThreadData();
+            pt->threadIndex=i+threadIndexStart;
+            pt->threadProc=threadProc;
+            pt->workData=workData;
+            pthread_t t; memset(&t,0,sizeof(pthread_t));
+            int rt=pthread_create(&t,0,_pt_threadProc,pt);
+            if (rt!=0){
+                delete pt;
+                _check_pthread(rt,"pthread_create");
+            }
+            rt=pthread_detach(t);
+            _check_pthread(rt,"pthread_detach");
+        }
+    }
+}
+#endif //_IS_USED_PTHREAD
+
+#if (_IS_USED_CPP11THREAD)
+HLocker locker_new(void){
+    return new std::mutex();
+}
+void locker_delete(HLocker locker){
+    if (locker!=0)
+        delete (std::mutex*)locker;
+}
+
+void locker_enter(HLocker locker){
+    std::mutex* self=(std::mutex*)locker;
+    self->lock();
+    
+}
+void locker_leave(HLocker locker){
+    std::mutex* self=(std::mutex*)locker;
+    self->unlock();
+}
+
+HCondvar condvar_new(void){
+    std::condition_variable* self=new std::condition_variable();
+    return self;
+} 
+void    condvar_delete(HCondvar cond){
+    if (cond){
+        std::condition_variable* self=(std::condition_variable*)cond;
+        delete self;
+    }
+}
+void    condvar_wait(HCondvar cond,TLockerBox* locker){
+    std::condition_variable* self=(std::condition_variable*)cond;
+    _TLockerBox_name* _locker=(_TLockerBox_name*)locker;
+    self->wait(*_locker);
+}
+void    condvar_signal(HCondvar cond){
+    std::condition_variable* self=(std::condition_variable*)cond;
+    self->notify_one();
+}
+void    condvar_broadcast(HCondvar cond){
+    std::condition_variable* self=(std::condition_variable*)cond;
+    self->notify_all();
+}
+
+void this_thread_yield(){
+    std::this_thread::yield();
+}
+
+
+struct _TThreadProc{
+    TThreadRunCallBackProc threadProc;
+    int   threadIndex;
+    void* workData;
+    inline void operator()(){  threadProc(threadIndex,workData);  }
+};
+void thread_parallel(int threadCount,TThreadRunCallBackProc threadProc,void* workData,
+                     int isUseThisThread,int threadIndexStart){
+    for (int i=0; i<threadCount; ++i) {
+        if ((i==threadCount-1)&&(isUseThisThread)){
+            threadProc(i+threadIndexStart,workData);
+        }else{
+            _TThreadProc tp={threadProc,i+threadIndexStart,workData};
+            std::thread t(tp);
+            t.detach();
+        }
+    }
+}
+#endif //_IS_USED_CPP11THREAD
+
+
+#if (_IS_USED_WIN32THREAD)
+#include <string.h> //for memset
+#include <stdlib.h>
+#include <stdexcept>
+#include <string>
+#include <stdio.h>
+
+#define _check(value,func_name) { \
+    if (!(value)) throw std::runtime_error(func_name "() run error!"); }
+
+
+HLocker locker_new(void){
+    CRITICAL_SECTION* self=new CRITICAL_SECTION();
+    InitializeCriticalSection(self);
+    return  self;
+}
+void locker_delete(HLocker locker){
+    if (locker!=0){
+        CRITICAL_SECTION* self=(CRITICAL_SECTION*)locker;
+        DeleteCriticalSection(self);
+        delete self;
+    }
+}
+
+void locker_enter(HLocker locker){
+    CRITICAL_SECTION* self=(CRITICAL_SECTION*)locker;
+    EnterCriticalSection(self);
+}
+void locker_leave(HLocker locker){
+    CRITICAL_SECTION* self=(CRITICAL_SECTION*)locker;
+    LeaveCriticalSection(self);
+}
+
+HCondvar condvar_new(void){
+    CONDITION_VARIABLE* self=new CONDITION_VARIABLE();
+    InitializeConditionVariable(self);
+    return self;
+}
+void    condvar_delete(HCondvar cond){
+    if (cond){
+        CONDITION_VARIABLE* self=(CONDITION_VARIABLE*)cond;
+        delete self;
+    }
+}
+void    condvar_wait(HCondvar cond,TLockerBox* lockerBox){
+    CONDITION_VARIABLE* self=(CONDITION_VARIABLE*)cond;
+    BOOL rt=SleepConditionVariableCS(self,(CRITICAL_SECTION*)(lockerBox->locker),INFINITE);
+    _check(rt,"SleepConditionVariableCS");
+}
+void    condvar_signal(HCondvar cond){
+    CONDITION_VARIABLE* self=(CONDITION_VARIABLE*)cond;
+    WakeConditionVariable(self);
+}
+void    condvar_broadcast(HCondvar cond){
+    CONDITION_VARIABLE* self=(CONDITION_VARIABLE*)cond;
+    WakeAllConditionVariable(self);
+}
+
+void this_thread_yield(){
+    Sleep(0);
+}
+
+struct _TThreadData{
+    TThreadRunCallBackProc  threadProc;
+    int                     threadIndex;
+    void*                   workData;
+};
+
+#ifdef UNDER_CE
+    static DWORD WINAPI _win_threadProc(void* _pt){
+#else
+    static unsigned int WINAPI _win_threadProc(void* _pt){
+#endif
+        _TThreadData* pt=(_TThreadData*)_pt;
+        pt->threadProc(pt->threadIndex,pt->workData);
+        delete pt;
+        return 0;
+    }
+
+template <class TProc>
+inline static HANDLE _thread_create(TProc func,void* param){
+#ifdef UNDER_CE
+    DWORD threadId;
+    return CreateThread(0,0,func,param,0,&threadId);
+#else
+    unsigned threadId;
+    return (HANDLE)_beginthreadex(0,0,func,param,0,&threadId);
+#endif
+}
+
+void thread_parallel(int threadCount,TThreadRunCallBackProc threadProc,void* workData,
+                     int isUseThisThread,int threadIndexStart){
+    for (int i=0; i<threadCount; ++i) {
+        if ((i==threadCount-1)&&(isUseThisThread)){
+            threadProc(i+threadIndexStart,workData);
+        }else{
+            _TThreadData* pt=new _TThreadData();
+            pt->threadIndex=i+threadIndexStart;
+            pt->threadProc=threadProc;
+            pt->workData=workData;
+            HANDLE rt=_thread_create(_win_threadProc,pt);
+            if (rt==0){
+                delete pt;
+                _check(rt!=0,"_thread_create");
+            } else {
+                CloseHandle(rt);    
+            }
+        }
+    }
+}
+#endif //_IS_USED_WIN32THREAD

package/harmony/pushy/src/main/cpp/HDiffPatch/libParallel/parallel_import.h

@@ -0,0 +1,92 @@
+//  parallel_import.h
+/*
+ The MIT License (MIT)
+ Copyright (c) 2018 HouSisong
+ 
+ Permission is hereby granted, free of charge, to any person
+ obtaining a copy of this software and associated documentation
+ files (the "Software"), to deal in the Software without
+ restriction, including without limitation the rights to use,
+ copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the
+ Software is furnished to do so, subject to the following
+ conditions:
+ 
+ The above copyright notice and this permission notice shall be
+ included in all copies of the Software.
+ 
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef parallel_import_h
+#define parallel_import_h
+
+//select define one for support parallel
+//#define _IS_USED_PTHREAD       1
+//#define _IS_USED_CPP11THREAD   1
+//#define _IS_USED_WIN32THREAD   1
+
+#ifndef _IS_USED_MULTITHREAD
+#   define _IS_USED_MULTITHREAD 1
+#endif
+
+#if ((_IS_USED_PTHREAD>0) || (_IS_USED_CPP11THREAD>0) || (_IS_USED_WIN32THREAD>0))
+#   //ok have one
+#   define _IS_USED_MULTITHREAD 1
+#else
+#   if (_IS_USED_MULTITHREAD>0)
+#       if ( (!(defined _IS_USED_WIN32THREAD)) && (defined _WIN32) )
+#           define  _IS_USED_WIN32THREAD        1
+#       else
+#           if ( (!(defined _IS_USED_CPP11THREAD)) && (__cplusplus >= 201103L) )
+#               define  _IS_USED_CPP11THREAD    1
+#           else
+#               if (!(defined _IS_USED_PTHREAD))
+#                   define _IS_USED_PTHREAD     1
+#               endif
+#           endif
+#       endif
+#   endif
+#endif
+
+#if (_IS_USED_MULTITHREAD)
+
+    //并行临界区锁;
+    typedef void*   HLocker;
+    HLocker     locker_new(void);
+    void        locker_delete(HLocker locker);
+    void        locker_enter(HLocker locker);
+    void        locker_leave(HLocker locker);
+    
+    //同步变量;
+    typedef void*   HCondvar;
+#if (_IS_USED_CPP11THREAD)
+#   define TLockerBox           void  /*  used std::unique_lock<std::mutex>  */
+#   define _TLockerBox_name     std::unique_lock<std::mutex>
+#else
+    typedef struct{
+        HLocker locker;
+    } TLockerBox;
+#endif
+    HCondvar    condvar_new(void);
+    void        condvar_delete(HCondvar cond);
+    void        condvar_wait(HCondvar cond,TLockerBox* lockerBox);
+    void        condvar_signal(HCondvar cond);
+    void        condvar_broadcast(HCondvar cond);
+
+    void this_thread_yield(void);
+
+    //parallel run
+    typedef void (*TThreadRunCallBackProc)(int threadIndex,void* workData);
+    void  thread_parallel(int threadCount,TThreadRunCallBackProc threadProc,void* workData,
+                          int isUseThisThread,int threadIndexStart);
+
+#endif //_IS_USED_MULTITHREAD
+#endif //parallel_import_h