C++ 多執行緒呼叫Python指令碼

阿新 • • 發佈：2019-01-22

由於Python直譯器有全域性解釋所GIL的原因，導致在同一時刻只能有一個執行緒擁有直譯器，所以在C++多執行緒呼叫python指令碼時，需要控制GIL，執行緒獲取GIL。

在主執行緒中初始化Python直譯器環境，程式碼如下：

		{
			Py_Initialize(); //初始化Python環境
			if ( !Py_IsInitialized() ) //檢測是否初始化成功
			{
				return NULL;
			}
			else
			{
				PyEval_InitThreads();     //開啟多執行緒支援
				int nInit = PyEval_ThreadsInitialized();  //檢測執行緒支援是否開啟成功
				if ( nInit )
				{
					PyEval_SaveThread();  //因為呼叫PyEval_InitThreads成功後，當前執行緒就擁有了GIL，釋放當前執行緒的GIL，
				}
			}
		}

然後可以建立子執行緒，在子執行緒呼叫中加入如下程式碼：

int nHold = PyGILState_Check() ;   //檢測當前執行緒是否擁有GIL
	PyGILState_STATE gstate;
	if ( !nHold )
	{
		gstate = PyGILState_Ensure();   //如果沒有GIL，則申請獲取GIL
	}
	Py_BEGIN_ALLOW_THREADS;
	Py_BLOCK_THREADS;
/**************************以下加入需要呼叫的python指令碼程式碼  Begin***********************/
/**************************以下加入需要呼叫的python指令碼程式碼  End***********************/
	Py_UNBLOCK_THREADS;
	Py_END_ALLOW_THREADS;
	if (!nHold)
	{
		PyGILState_Release(gstate);    //釋放當前執行緒的GIL
	}

boost::python對Python原生的C API有較好的封裝，可以很方便通過C++對python指令碼進行呼叫一下是一些學習總結，以便今後需要使用的時候能快速使用
假設有python模組 School.py 包含類 Student 和函式 Call 和返回類物件的CallClass方法

class Student():
	def __init__(name,age,properties):
		self.name = name
		self.age = age
		self.properties = proterties

	def show():
		print(self.name, slef.age, self.properties)

def Call(p1,p2):
	print(p1,p2)
	return "yes"

def CallClass():
	s = Student("universal",20,"good")
	return s

以下為C++呼叫python指令碼程式碼：
1> 在C++中構造python中定義的類，並且呼叫類方法

boost::python::handle<>* school_module = NULL;
string strModule = "School";
school_module = new boost::python::handle<>(PyImport_ImportModule((char*)strModule.c_str()));    //通過模組名稱獲取模組handle
boost::python::object main_module(*manager_module);     //轉化為boost::python::object型別表示的模組 
boost::python::object main_namespace = main_module.attr("__dict__");   //得到模組內的字典，字典中包含了 所有的類和函式
boost::python::handle<> Student;    //定義一個Student類 的handle
//得到Student類的例項，引數可以任意傳遞  比如以下設定properties為一個dict
Student = boost::python::handle<>((PyRun_String(
"Student('alen',30,{\"errorcode\":0, \"message\":\"execute succeed\"})", Py_eval_input,
main_namespace.ptr(), main_namespace.ptr())));

/*********以下將properties設定為一個tuple
Student = boost::python::handle<>((PyRun_String(
"Student('alen',30,(1,2,3,4,5))", Py_eval_input,
main_namespace.ptr(), main_namespace.ptr())));
**********/

/*********以下將properties設定為一個list
Student = boost::python::handle<>((PyRun_String(
"Student('alen',30,[1,2,3,4,5])", Py_eval_input,
main_namespace.ptr(), main_namespace.ptr())));
**********/
/**********
//通過Student類呼叫類方法show
boost::python::object result = boost::python::call_method<boost::python::object>(Student.get(), "show");

2>呼叫指令碼中的函式 Call 假設傳遞的第一個引數為string 第二個為int

boost::python::handle<>* school_module = NULL;
string strModule = "School";
school_module = new boost::python::handle<>(PyImport_ImportModule((char*)strModule.c_str()));    //通過模組名稱獲取模組handle
boost::python::object result = boost::python::call_method<boost::python::object>(school_module->get(),"Call","schoolname",2);

3>呼叫指令碼時，可以傳遞各種引數，boost 已經封裝了boost::python::dict 對應dict boost::python::tuple對應 tuple

比如構造dict引數，程式碼如下：

boost::python::dict inParams;
inParams.setdefault<std::string,std::string>("name","clear");
inParams.setdefault<std::string,std::string>("code","56821334");
inParams.setdefault<std::string,int>("number",123456);

4>處理返回的資料比如 python類型別

boost::python::handle<>* school_module = NULL;
string strModule = "School";
school_module = new boost::python::handle<>(PyImport_ImportModule((char*)strModule.c_str()));    //通過模組名稱獲取模組handle
boost::python::object student = boost::python::call_method<boost::python::object>(school_module->get(),"CallClass");
//可以通過返回的類物件 繼續呼叫類Student 的 show方法 如下：
boost::python::object q = boost::python::call_method<boost::python::object>(student.ptr(), "show");
//也可以獲取類的屬性值 比如 name  string 型別  和 age  Int型別
boost::python::object obj_dict  = student.attr("__dict__");   //獲取物件的字典
//獲取name
boost::python::object name = obj_dict["name"];
std::string sname = boost::python::extract<std::string>(name);
//獲取age
boost::python::object age = obj_dict["age"];
int age = boost::python::extract<int>(age);

將全域性直譯器鎖和執行緒的相關操作用類封裝，使用建構函式和解構函式去做locker 和 unlocker的操作

/*全域性解釋和執行緒鎖*/
class PyGILThreadLock
{
public:
	PyGILThreadLock()
	{
		_save = NULL;
		nStatus = 0;
		nStatus = PyGILState_Check() ;   //檢測當前執行緒是否擁有GIL  
		PyGILState_STATE gstate;  
		if ( !nStatus )  
		{  
			gstate = PyGILState_Ensure();   //如果沒有GIL，則申請獲取GIL 
			nStatus = 1;
		}  
		_save = PyEval_SaveThread();
		PyEval_RestoreThread(_save);
	}
	~PyGILThreadLock()
	{
		_save = PyEval_SaveThread();
		PyEval_RestoreThread(_save);
		if (nStatus)  
		{  
			PyGILState_Release(gstate);    //釋放當前執行緒的GIL  
		}  
	}

private:
	PyGILState_STATE gstate; 
	PyThreadState *_save;
	int nStatus;
};

在程式碼中呼叫時，只需要

{
        PyGILThreadLock  locker;
///////以下新增python呼叫程式碼
}

使用boost::python的時候捕獲異常獲取異常資訊

std::string GetPythonErrorInfo(void)  
{   
	using namespace boost::python;                                  

	PyObject *exc,*val,*tb;                                         
	PyErr_Fetch(&exc,&val,&tb);                                     
	PyErr_NormalizeException(&exc,&val,&tb);                        
	handle<> hexc(exc),hval(allow_null(val)),htb(allow_null(tb));   
	if(!hval)                                                       
	{
		return extract<std::string>(str(hexc));                       
	}                                                               
	else                                                            
	{                                                               
		object traceback(import("traceback"));                        
		object format_exception(traceback.attr("format_exception"));  
		object formatted_list(format_exception(hexc,hval,htb));       
		object formatted(str("").join(formatted_list));               
		return extract<std::string>(formatted);                       
	}                                                        
}

以下為VC控制檯測試程式

#include "stdafx.h"
#include <Windows.h>
#include <iostream>
#include <process.h>
#include <boost/python.hpp>
using namespace std;

#define Check_Init(init)  \
	if(!init){\
	cout<<"請先通過init指令初始化python環境"<<endl;\
	goto __next;\
	}


bool bInit = false;
std::string strModule = "manager";

unsigned int __stdcall ThreadCall(void* lparam)
{
	char szMessage[1024] = { 0 };
	int id  = GetCurrentThreadId();
	sprintf_s(szMessage,sizeof(szMessage),"thread id: %d ",id);
	std::string sResult = "";
	boost::python::handle<>* manager_module = NULL;
	for ( int i = 0 ; i < 2000 ; i ++)
	{
		PyGILThreadLock locker;
		manager_module = new boost::python::handle<>(PyImport_ImportModule((char*)strModule.c_str()));
		sResult = boost::python::call_method<std::string>(manager_module->get(),"threadcall",szMessage);
		cout<<sResult.c_str()<<endl;

		delete manager_module;
		manager_module = NULL;
	}
	return 0;
}

void callsay(const char* szMessage)
{
	boost::python::handle<>* manager_module = NULL;
	std::string sResult = "";
	PyGILThreadLock locker;
	try
	{	
		manager_module = new boost::python::handle<>(PyImport_ImportModule((char*)strModule.c_str()));
		sResult = boost::python::call_method<std::string>(manager_module->get(),"say",szMessage);
	}
	catch(...)
	{
		delete manager_module;
		manager_module = NULL;
		cout<<"捕獲一個異常在callsay方法中"<<endl;
	}
	delete manager_module;
	manager_module = NULL;
}

int _tmain(int argc, _TCHAR* argv[])
{
	char szCommand[20]={0}  ;
	cout<<"請輸入指令"<<endl;
	cin>>szCommand;
	while ( strcmp("quit",szCommand) != 0 )
	{
		if ( strcmp("threadcall",szCommand) == 0 )
		{
			Check_Init(bInit);
			for ( int i = 0 ; i < 5; i++ )
			{
				_beginthreadex(NULL,
					0,
					ThreadCall,
					NULL,
					0,
					NULL);
			}
		}
		else if ( strcmp("init",szCommand) == 0 )
		{
			if ( bInit )
			{
				cout<<"Python 環境已經初始化"<<endl;
				continue;
			}
			Py_Initialize(); //初始化Python環境
			if ( !Py_IsInitialized() ) //檢測是否初始化成功
			{
				cout<<"Python環境初始化失敗"<<endl;
				return NULL;
			}
			else
			{
				PyEval_InitThreads();     //開啟多執行緒支援
				int nInit = PyEval_ThreadsInitialized();  //檢測執行緒支援是否開啟成功
				if ( nInit )
				{
					PyEval_SaveThread();  //因為呼叫PyEval_InitThreads成功後，當前執行緒就擁有了GIL，釋放當前執行緒的GIL，
				}
				bInit = true;
				cout<<"Python環境初始化成功,退出前請使用free指令釋放Python環境"<<endl;
			}	
		}
		else if ( strcmp("say",szCommand) == 0 )
		{
			Check_Init(bInit);
			std::string msg = "Python Manager";
			callsay(msg.c_str());
		}
		else if ( strcmp("free",szCommand) == 0 )
		{
			Py_Finalize();
			bInit = false;
			cout<<"Python直譯器環境被釋放"<<endl;
		}
		else{
			cout<<"未識別的指令資訊"<<endl;
			
		}
__next:
		memset(szCommand,0,20);
		cin>>szCommand;
	}
	system("pause");
	return 0;
}

新增一個測試過程中的程式碼，因為還封裝了類所以單獨編譯不過，用來標記一下吧，方便下次在使用的時候可以快速的重新學習

// PythonManager.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <Windows.h>
#include <iostream>
#include <process.h>
// #include <boost/python.hpp>
// #include "Python.h"
#include "PythonAssister.h"
using namespace std;

#define Check_Init(init)  \
	if(!init){\
	cout<<"請先通過init指令初始化python環境"<<endl;\
	goto __next;\
	}


bool bInit = false;
std::string strModule = "manager";

unsigned int __stdcall ThreadCall(void* lparam)
{
	char szMessage[1024] = { 0 };
	int id  = GetCurrentThreadId();
	sprintf_s(szMessage,sizeof(szMessage),"thread id: %d ",id);
	std::string sResult = "";
	boost::python::handle<>* manager_module = NULL;
	for ( int i = 0 ; i < 2000 ; i ++)
	{
		PyGILThreadLock locker;
// 		int nHold = PyGILState_Check() ;   //檢測當前執行緒是否擁有GIL  
// 		PyGILState_STATE gstate;  
// 		if ( !nHold )  
// 		{  
// 			gstate = PyGILState_Ensure();   //如果沒有GIL，則申請獲取GIL  
// 		}  
// 		Py_BEGIN_ALLOW_THREADS;  
// 		Py_BLOCK_THREADS; 
		manager_module = new boost::python::handle<>(PyImport_ImportModule((char*)strModule.c_str()));
		sResult = boost::python::call_method<std::string>(manager_module->get(),"threadcall",szMessage);
		cout<<sResult.c_str()<<endl;
// 		Py_UNBLOCK_THREADS;  
// 		Py_END_ALLOW_THREADS;  
// 		if (!nHold)  
// 		{  
// 			PyGILState_Release(gstate);    //釋放當前執行緒的GIL  
// 		} 
	}
	return 0;
}


void calltest()
{
	PyGILThreadLock locker;
	boost::python::handle<>* manager_module = NULL;
	manager_module = new boost::python::handle<>(PyImport_ImportModule((char*)strModule.c_str()));
	boost::python::object result = boost::python::call_method<boost::python::object>(manager_module->get(),"calltest");
	cout<< result.ptr()->ob_type->tp_name<<endl;
	boost::python::object q = boost::python::call_method<boost::python::object>(result.ptr(), "show");
	boost::python::object r1  = result.attr("__dict__");
	boost::python::object r2 = r1["name"];
//	boost::python::call_method<boost::python::object>(r1,"__getdict__","name");
	std::string sname = boost::python::extract<std::string>(r2);
	cout<<sname.c_str()<<endl;
	delete manager_module;
	manager_module = NULL;

}

void classtest()
{
	PyGILThreadLock locker;
	boost::python::handle<>* manager_module = NULL;
	try
	{
		manager_module = new boost::python::handle<>(PyImport_ImportModule((char*)strModule.c_str()));
		boost::python::object main_module(*manager_module);
		boost::python::object main_namespace = main_module.attr("__dict__");
		boost::python::handle<> Student;
		Student = boost::python::handle<>((PyRun_String(
			"Student('alen',30,{\"errorcode\":0, \"message\":\"execute succeed\"})", Py_eval_input,
			main_namespace.ptr(), main_namespace.ptr())));
		boost::python::object result = boost::python::call_method<boost::python::object>(Student.get(), "show");

	}
	catch(...)
	{
		PyErr_Print();
		PyErr_Clear();
	}

}

 void calldict()
 {
 	boost::python::handle<>* manager_module = NULL;
 	boost::python::dict mydict;
 	int nHold = PyGILState_Check() ;   //檢測當前執行緒是否擁有GIL  
 	PyGILState_STATE gstate;  
 	if ( !nHold )  
 	{  
 		gstate = PyGILState_Ensure();   //如果沒有GIL，則申請獲取GIL  
 	}  
 	Py_BEGIN_ALLOW_THREADS;  
 	Py_BLOCK_THREADS; 
 	try
 	{	
 		boost::python::dict inParams;
 		inParams.setdefault<std::string,std::string>("name","clear");
 		inParams.setdefault<std::string,std::string>("code","56821334");
 		inParams.setdefault<std::string,int>("number",123456);
 		int nLenDict = len(inParams);
 		const char* szType = inParams.ptr()->ob_type->tp_name;
 		boost::python::list dictlist;
 		dictlist = inParams.items();
 		int nLenList = len(dictlist);
 		for ( int i = 0 ; i< nLenList; i++ )
 		{
 			boost::python::object obj;
 			
 			obj = dictlist.pop();
 			const char* szType = obj.ptr()->ob_type->tp_name;
 			int n = PyType_Check(obj.ptr());
 			int nLenTuple = len(obj);
 			for ( int j = 0 ; j <nLenTuple; j++ )
 			{
 				int n1 = PyType_Check(((boost::python::object)obj[j]).ptr());
 				std::string value = boost::python::extract<std::string>(obj[j]);
 				
 				boost::python::extract<const std::string&>ex((obj[j]));
 				if ( ex.check() )
 				{
 					cout<<"yes it is string"<<endl;
 				}
 				cout<<value.c_str()<<endl;
 			}
 		}
 		//boost::python::tuple
  		boost::python::object itemTuple;
  		itemTuple = dictlist.pop();
  		while ( itemTuple != NULL )
  		{
  			int nLen = len(itemTuple);
  			string strKey = boost::python::extract<std::string>(itemTuple[0]);
  			string strValue = boost::python::extract<std::string>(itemTuple[1]);
  			itemTuple = dictlist.pop();
  			int a = 10;
  		}
 		
 
 
 		manager_module = new boost::python::handle<>(PyImport_ImportModule((char*)strModule.c_str()));
 		//mydict = boost::python::call_method<boost::python::dict>(manager_module->get(),"calldict",inParams);
 		boost::python::object result = boost::python::call_method<boost::python::object>(manager_module->get(),"calldict",inParams);
 		const char* szType1 = result.ptr()->ob_type->tp_name;
 		cout<<"Type : "<<szType1<<endl;
 		
 	}
 	catch(...)
 	{
 // 		delete manager_module;
 // 		manager_module = NULL;
 		cout<<"捕獲一個異常在calldict方法中"<<endl;
 	}
 	if ( NULL != manager_module )
 	{
 		delete manager_module;
 		manager_module = NULL;
 	}
 
 	Py_UNBLOCK_THREADS;  
 	Py_END_ALLOW_THREADS;  
 	if (!nHold)  
 	{  
 		PyGILState_Release(gstate);    //釋放當前執行緒的GIL  
 	}  
}



void callsay(const char* szMessage)
{
	boost::python::handle<>* manager_module = NULL;
	std::string sResult = "";
	int nHold = PyGILState_Check() ;   //檢測當前執行緒是否擁有GIL  
	PyGILState_STATE gstate;  
	if ( !nHold )  
	{  
		gstate = PyGILState_Ensure();   //如果沒有GIL，則申請獲取GIL  
	}  
	Py_BEGIN_ALLOW_THREADS;  
	Py_BLOCK_THREADS; 
	try
	{	
		manager_module = new boost::python::handle<>(PyImport_ImportModule((char*)strModule.c_str()));
		sResult = boost::python::call_method<std::string>(manager_module->get(),"say",szMessage);
	}
	catch(...)
	{
		delete manager_module;
		manager_module = NULL;
		cout<<"捕獲一個異常在callsay方法中"<<endl;
	}
	delete manager_module;
	manager_module = NULL;
	Py_UNBLOCK_THREADS;  
	Py_END_ALLOW_THREADS;  
	if (!nHold)  
	{  
		PyGILState_Release(gstate);    //釋放當前執行緒的GIL  
	}  
}

int _tmain(int argc, _TCHAR* argv[])
{
	char szCommand[20]={0}  ;
	cout<<"請輸入指令"<<endl;
	cin>>szCommand;
	while ( strcmp("quit",szCommand) != 0 )
	{
		if ( strcmp("threadcall",szCommand) == 0 )
		{
			Check_Init(bInit);
			for ( int i = 0 ; i < 5; i++ )
			{
				_beginthreadex(NULL,
					0,
					ThreadCall,
					NULL,
					0,
					NULL);
			}
		}
		else if ( strcmp("classtest",szCommand) == 0 )
		{
			classtest();
		}
		else if ( strcmp("init",szCommand) == 0 )
		{
			if ( bInit )
			{
				cout<<"Python 環境已經初始化"<<endl;
				continue;
			}
			Py_Initialize(); //初始化Python環境
			if ( !Py_IsInitialized() ) //檢測是否初始化成功
			{
				cout<<"Python環境初始化失敗"<<endl;
				return NULL;
			}
			else
			{
				PyEval_InitThreads();     //開啟多執行緒支援
				int nInit = PyEval_ThreadsInitialized();  //檢測執行緒支援是否開啟成功
				if ( nInit )
				{
					PyEval_SaveThread();  //因為呼叫PyEval_InitThreads成功後，當前執行緒就擁有了GIL，釋放當前執行緒的GIL，
				}
				bInit = true;
				cout<<"Python環境初始化成功,退出前請使用free指令釋放Python環境"<<endl;
			}	
		}
		else if ( strcmp("say",szCommand) == 0 )
		{
			Check_Init(bInit);
			std::string msg = "Python Manager";
			callsay(msg.c_str());
		}
		else if ( strcmp("calldict",szCommand) == 0 )
		{
			Check_Init(bInit);
			std::string msg = "Python Manager";
			calldict();
		}
		else if ( strcmp("free",szCommand) == 0 )
		{
			int nHold = PyGILState_Check() ;   //檢測當前執行緒是否擁有GIL  
			PyGILState_STATE gstate;  
			if ( !nHold )  
			{  
				gstate = PyGILState_Ensure();   //如果沒有GIL，則申請獲取GIL  
			}  
			Py_Finalize();
			bInit = false;
			cout<<"Python直譯器環境被釋放"<<endl;
		}
		else{
			cout<<"未識別的指令資訊"<<endl;
			
		}
__next:
		memset(szCommand,0,20);
		cin>>szCommand;
	}
	system("pause");
	return 0;
}

C++ 多執行緒呼叫Python指令碼

由於Python直譯器有全域性解釋所GIL的原因，導致在同一時刻只能有一個執行緒擁有直譯器，所以在C++多執行緒呼叫python指令碼時，需要控制GIL，執行緒獲取GIL。在主執行緒中初始化Python直譯器環境，程式碼如下： { Py_Initialize()

C# 多執行緒呼叫靜態方法或者靜態例項中的同一個方法-方法內部的變數是執行緒安全的

C# 多執行緒呼叫靜態方法或者靜態例項中的同一個方法-方法內部的變數是執行緒安全的 using System;using System.Threading;using System.Threading.Tasks;using Sys

C#多執行緒呼叫有參的方法

Thread (ParameterizedThreadStart) 初始化 Thread 類的新例項，指定允許物件線上程啟動時傳遞給執行緒的委託。 Thread (ThreadStart) 初始化 Thread 類的新例項。由 .NET Compact Fra

C# Webbrowser 常用方法及多執行緒呼叫

public partial class htmlElement { //根據Name獲取元素 public HtmlElement GetElement_Name(WebBrowser wb, string Name) { H

C# 使用委託實現多執行緒呼叫窗體的四種方式

1、方法一：使用執行緒功能描述：在用c#做WinFrom開發的過程中。我們經常需要用到進度條（ProgressBar）用於顯示進度資訊。這時候我們可能就需要用到多執行緒，如果不採用多執行緒控制進度條，視窗很容易假死（無法適時看到進度資訊）。下面

C#多執行緒的非同步委託/呼叫

C#非同步呼叫（Asynchronou Delegate） C#非同步呼叫獲取結果方法：主要有三種，也可以說是四種（官方說四種，電子書說三種），官方在MSDN上已經有詳細的說明：連結需要了解到獲取非同步執行的返回值，意味著你需要呼叫Delegate的BeginIn

C# 多執行緒詳解 Part.02（UI 執行緒和子執行緒的互動、ProgressBar 的非同步呼叫）

我們先來看一段執行時會丟擲 InvalidOperationException 異常的程式碼段: private void btnThreadA_Click(object sender, EventArgs e) { Thread thread

C# 多執行緒用委託實現非同步_呼叫委託的BeginInvoke和EndInvoke方法

1.C#中的每一個委託都內建了BeginInvoke和EndInvoke方法，如果委託的方法列表裡只有一個方法，那麼這個方法就可以非同步執行（不在當前執行緒裡執行，另開闢一個執行緒執行）。委託的BeginInvoke和EndInvoke方法就是為了上述目的而生的。 2.原始

c/c++ 多執行緒 std::lock

多執行緒 std::lock 當要同時操作2個物件時，就需要同時鎖定這2個物件，而不是先鎖定一個，然後再鎖定另一個。同時鎖定多個物件的方法：std::lock(物件1.鎖，物件2.鎖...) 額外說明：lock_guard<mutex> lock_a(d1.m, std::adopt_lock

C#多執行緒順序依賴執行控制

在開發過程中，經常需要多個任務並行的執行的場景，同時任務之間又需要先後依賴的關係。針對這樣的處理邏輯，通常會採用多執行緒的程式模型來實現。比如A、B、C三個執行緒，A和B需要同時啟動，並行處理，且B需要依賴A完成，在進行後續的處理，C需要B完成後開始處理。

C/C++ 多執行緒機制

一、C/C++多執行緒操作說明 C/C++多執行緒基本操作如下： 1. 執行緒的建立結束 2. 執行緒的互斥和同步 3. 使用訊號量控制執行緒 4. 執行緒的基本屬性配置在C/C++程式碼編寫時，使用多執行緒機制，首先需要做的事情就是宣告引用，具體如下

c/c++ 多執行緒 std::once

多執行緒 std::once 轉自：https://blog.csdn.net/hengyunabc/article/details/33031465 std::once的特點：即使有多個執行緒要訪問同一個函式，只有一個執行緒會成功。 std::once的用途：當某個資料只有在初始化的時候需要執行緒安全

C#多執行緒基礎（多執行緒的優先順序、狀態、同步）

一、關於多執行緒的優先順序、狀態、同步指令碼如下： using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading; using System

C++多執行緒之std::thread

C++11，包含標頭檔案 thread.h，並使用名稱空間std。 thread類提供的方法方法描述 thread 建構函式，在這裡傳入執行緒執行函式，和函式引數

C++ 多執行緒pthread 學習筆記

本篇是我在學習C++多執行緒的時候做的筆記，主要記錄的是基礎的流程，部分程式碼例項，以及重點函式的說明。 pthread 入口函式型別說明 void * func1(void * t) void* 表示無型別指標 void*作為函式引數，表示函式接收一個指標，不管是什麼型別

2017.10.21 C# 多執行緒控制控制元件例項

直接上程式碼片段 using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Text

2017.10.12 C#多執行緒與非同步的區別

最近在寫個多執行緒處理的程式，又重新溫習了一下相關知識，記錄在這裡。 C#多執行緒與非同步的區別原文地址：http://kb.cnblogs.com/page/116095/ 多執行緒和非同步操作的異同　　多執行緒和非同步操作兩者都可以達到避免呼叫執行緒阻塞的目的，從而提高軟體

linux c 多執行緒開發

在開發多執行緒程式時，當建立的執行緒數量特別多的時候，就會遇到執行緒數量的瓶頸。多執行緒設定設定核心引數 kernel.threads-max kernel.threads-max 是 linux 系統允許建立的最大執行緒數，預設是 7767 修改 /etc/sysc

C++:蟻群演算法解決TSP（C++多執行緒版）

TSP問題：旅行商問題，最短迴路。這裡採用att48資料，鄰接矩陣全部取整數，原資料放在文後。解決程式碼如下： //#define TEST_INPUT //#define TEST_T //#define TEST_ANT //#define TEST_VALUE #

c/c++ 多執行緒 ubuntu18.04 boost編譯與執行的坑

多執行緒 boost編譯與執行的坑背景：因為要使用boost裡的多執行緒庫，所以遇到了下面的坑。系統版本：ubuntu18.04 一，安裝boost 1，去boost官網下載 boost_1_XX_0.tar.gz 2，解壓 tar -zxvf boost_1_65_0.tar.gz 3

C++ 多執行緒呼叫Python指令碼

相關推薦