• C++中双线程调用网络摄像头，用多线程调用多个摄像头并同步执行算法

              在调用网络摄像头处理自己的算法时，当解码的速度与算法运行的速度差太多时，会出现类似下面的错误

    error while decoding MB 148 4, bytestream

    所以需要使用两个线程，一个线程调用摄像头，一个线程用来处理图像。

    一、使用双线程调用网络摄像头，并执行算法

    方法一：

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8.  
    9. static std::mutex mutex;
    10. static std::atomic_bool isOpen;
    11.  
    12. static void cameraThreadFunc(std::string camId, cv::Mat* pFrame)
    13. {
    14.     cv::VideoCapture capture(camId);
    15.     //capture.set(cv::CAP_PROP_FOURCC, CV_FOURCC('M', 'J', 'P', 'G'));
    16.     capture.set(cv::CAP_PROP_FPS, 30);
    17.  
    18.     if (!capture.isOpened()) {
    19.         isOpen = false;
    20.         std::cout << "Failed to open camera with index " << camId << std::endl;
    21.     }
    22.  
    23.     cv::Mat frame;
    24.     while (isOpen) {
    25.         capture >> frame;
    26.         if (mutex.try_lock()) {
    27.             frame.copyTo(*pFrame);
    28.             mutex.unlock();
    29.         }
    30.         cv::waitKey(5);
    31.     }
    32.     capture.release();
    33. }
    34.  
    35.  
    36. int main(int argc, char* argv[])
    37. {
    38.     std::string rtsps = "rtsp://admin:bs123456@192.168.1.64:554/h264/ch1/main/av_stream/1";
    39.     isOpen = true;
    40.     cv::Mat frame(1440, 2560, CV_8UC3);
    41.     //cv::Mat* frame = new cv::Mat(1440, 2560, CV_8UC3);
    42.     std::thread thread(cameraThreadFunc, rtsps, &frame); //调用摄像头
    43.     //std::thread thread(cameraThreadFunc, rtsps, frame);
    44.  
    45.     
    46.     //*****************************************************
    47.     //调用自己的算法处理图像
    48.     void* p_algorithm;
    49.     p_algorithm = (void*)(new WindNetDetect());
    50.     std::string net_bins = "./models/visdrone_1009-opt.bin";
    51.     std::string net_paras = "./models/visdrone_1009-opt.param";
    52.     int init_res = ((WindNetDetect*)p_algorithm)->init1(net_bins, net_paras);
    53.     WindNetDetect* tmp = (WindNetDetect*)(p_algorithm);
    54.     std::vector objects;
    55.     //*****************************************************
    56.     
    57.     while (isOpen) {
    58.  
    59.         //*********************************
    60.         //调用目标检测的算法
    61.         tmp->detect(frame, objects);
    62.         tmp->draw_objects(frame, objects);
    63.         //*********************************
    64.  
    65.         if (cv::waitKey(1) == 'q') {
    66.             break;
    67.         }
    68.     }
    69.  
    70.     frame.release();
    71.  
    72.     isOpen = false;
    73.     thread.join();
    74.     return 0;
    75. }
    76.  
      77.  

       方法二：
       

      1. // video_test.cpp
      2. #include 
      3. #include 
      4. #include 
      5. #include 
      6. #include 
      7. #include 
      8. #include 
      9. #include 
      10.  
      11. class VideoCaptureMT {
      12. public:
      13. 	VideoCaptureMT(int index, int height=480, int width=640);
      14. 	VideoCaptureMT(std::string filePath, int height=480, int width=640);
      15. 	~VideoCaptureMT();
      16. 	
      17. 	bool isOpened() {
      18. 		return m_IsOpen;
      19. 	}
      20. 	void release() {
      21. 		m_IsOpen = false;
      22. 	}
      23. 	bool read(cv::Mat& frame);
      24.  
      25. private:
      26. 	void captureInit(int index, std::string filePath, int height, int width);
      27. 	void captureFrame();
      28.  
      29. 	cv::VideoCapture* m_pCapture;
      30. 	cv::Mat* m_pFrame;
      31. 	std::mutex* m_pMutex;
      32. 	std::thread* m_pThread;
      33. 	std::atomic_bool m_IsOpen;
      34. };
      35.  
      36. VideoCaptureMT::VideoCaptureMT(int index, int height, int width)
      37. {
      38. 	captureInit(index, std::string(), height, width);
      39. }
      40.  
      41. VideoCaptureMT::VideoCaptureMT(std::string filePath, int height, int width)
      42. {
      43. 	captureInit(0, filePath, height, width);
      44. }
      45.  
      46. VideoCaptureMT::~VideoCaptureMT()
      47. {
      48. 	m_IsOpen = false;
      49. 	m_pThread->join();
      50. 	if (m_pCapture->isOpened()) {
      51. 		m_pCapture->release();
      52. 	}
      53.  
      54. 	delete m_pThread;
      55. 	delete m_pMutex;
      56. 	delete m_pCapture;
      57. 	delete m_pFrame;
      58. }
      59.  
      60. void VideoCaptureMT::captureInit(int index, std::string filePath, int height, int width)
      61. {
      62. 	if (!filePath.empty()) {
      63. 		m_pCapture = new cv::VideoCapture(filePath);
      64. 	}
      65. 	else {
      66. 		m_pCapture = new cv::VideoCapture(index);
      67. 	}
      68. 	m_pCapture->set(cv::CAP_PROP_FRAME_WIDTH, width);
      69. 	m_pCapture->set(cv::CAP_PROP_FRAME_HEIGHT, height);
      70. 	m_pCapture->set(cv::CAP_PROP_FPS, 30);
      71. 	
      72. 	m_IsOpen = true;
      73. 	m_pFrame = new cv::Mat(height, width, CV_8UC3);
      74. 	m_pMutex = new std::mutex();
      75. 	m_pThread = new std::thread(&VideoCaptureMT::captureFrame, this);
      76. }
      77.  
      78. void VideoCaptureMT::captureFrame()
      79. {
      80. 	cv::Mat frameBuff;
      81. 	while (m_IsOpen) {
      82. 		(*m_pCapture) >> frameBuff;
      83. 		if (m_pMutex->try_lock()) {
      84. 			frameBuff.copyTo(*m_pFrame);
      85. 			m_pMutex->unlock();
      86. 		}
      87. 		cv::waitKey(5);
      88. 	}
      89. }
      90.  
      91. bool VideoCaptureMT::read(cv::Mat& frame)
      92. {
      93. 	if (m_pFrame->empty()) {
      94. 		m_IsOpen = false;
      95. 	}
      96. 	else {
      97. 		m_pMutex->lock();
      98. 		m_pFrame->copyTo(frame);
      99. 		m_pMutex->unlock();
      100. 	}
      101. 	return m_IsOpen;
      102. }
      103.  
      104. int main(int argc, char* argv[])
      105. {
      106. 	VideoCaptureMT capture(0);
      107. 	cv::Mat frame, gray;
      108. 	while (capture.isOpened()) {
      109. 		if (!capture.read(frame)) {
      110. 			break;
      111. 		}
      112. 		cv::cvtColor(frame, gray, cv::COLOR_BGR2GRAY);
      113. 		cv::blur(gray, gray, cv::Size(3, 3));
      114. 		cv::Canny(gray, gray, 5 , 38 , 3);
      115. 		cv::waitKey(100);
      116.  
      117. 		cv::imshow("image", gray);
      118.         if (cv::waitKey(5) == 'q') {
      119. 			break;
      120. 		}
      121. 	}
      122. 	capture.release();
      123. 	return 0;
      124. }
       

       二、使用多线程调用多路摄像头并同步执行多个算法：
       

              使用两个线程调用两个函数，get_cam1中包含了调用网络摄像头的类VideoCaptureMT （见上面代码），以及调用算法。另外一个函数是一样的。代码如下 ：
       

      1. void get_cam1()
      2. {
      3. 	clock_t start, end, end1, end2;
      4.  
      5.  
      6. 	std::string rtsps = "rtsp://admin:bs123456@192.168.1.64:554/h264/ch1/main/av_stream/1";
      7.  
      8. 	VideoCaptureMT capture(rtsps);
      9. 	//VideoCaptureMT capture, captureusb;
      10.  
      11. 	cv::namedWindow("外接摄像头检测", 0);
      12. 	cv::Mat frame, gray;
      13.  
      14.  
      15. 	while (capture.isOpened()) {
      16. 		std::lock_guard mtx_locker(mtx);
      17.  
      18. 		start = clock();
      19. 		if (!capture.read(frame)) {
      20. 			break;
      21. 		}
      22. 		//gray = frame;
      23. 		end = clock();
      24. 		std::vector objects;
      25. 		tmp->detect(frame, objects);
      26.  
      27.  
      28. 		for (size_t i = 0; i < objects.size(); i++)
      29. 		{
      30. 			const Object& obj = objects[i];
      31. 			fprintf(stderr, "%d = %.5f at %.2f %.2f %.2f x %.2f\n", obj.label, obj.prob,
      32. 				obj.rect.x, obj.rect.y, obj.rect.width, obj.rect.height);
      33.  
      34. 			cv::rectangle(frame, obj.rect, cv::Scalar(255, 0, 0));
      35.  
      36. 			char text[256];
      37. 			//sprintf(text, "%s %.1f%%", class_names[obj.label], obj.prob * 100);
      38. 			sprintf(text, "%s", class_names[obj.label]);
      39.  
      40. 			int baseLine = 0;
      41. 			cv::Size label_size = cv::getTextSize(text, cv::FONT_HERSHEY_SIMPLEX, 0.5, 1, &baseLine);
      42.  
      43. 			int x = obj.rect.x;
      44. 			int y = obj.rect.y - label_size.height - baseLine;
      45. 			if (y < 0)
      46. 				y = 0;
      47. 			if (x + label_size.width > frame.cols)
      48. 				x = frame.cols - label_size.width;
      49.  
      50. 			cv::rectangle(frame, cv::Rect(cv::Point(x, y), cv::Size(label_size.width, label_size.height + baseLine)),
      51. 				cv::Scalar(255, 255, 255), -1);
      52.  
      53. 			cv::putText(frame, text, cv::Point(x, y + label_size.height),
      54. 				cv::FONT_HERSHEY_SIMPLEX, 0.5, cv::Scalar(0, 0, 0));
      55. 		}
      56.  
      57. 		//cv::imwrite("./result20.jpg", image);
      58.  
      59. 		cv::imshow("外接摄像头检测", frame);
      60.  
      61. 		end2 = clock();
      62.  
      63. 		float rumtime = (float)(end2 - start) / CLOCKS_PER_SEC;
      64. 		std::stringstream buf;
      65. 		buf.precision(3);//����Ĭ�Ͼ���
      66. 		buf.setf(std::ios::fixed);//����С��λ
      67. 		buf << rumtime;
      68. 		std::string strtime;
      69. 		strtime = buf.str();
      70. 		std::cout << "strtime1111 = " << strtime << std::endl;
      71. 		//start = end2;
      72.  
      73. 		if (cv::waitKey(5) == 'q') {
      74. 			break;
      75. 		}
      76.  
      77. 	}
      78. 	capture.release();
      79. 	
      80. }
      81.  
      82. void get_camusb()
      83. {
      84. 	clock_t start, end, end1, end2;
      85.  
      86. 	std::string rtsps = "rtsp://wowzaec2demo.streamlock.net/vod/mp4:BigBuckBunny_115k.mp4";
      87. 	VideoCaptureMT capture(rtsps);
      88.  
      89. 	cv::Mat frameusb;
      90. 	cv::namedWindow("外接摄像头检测1", 0);
      91.  
      92. 	//void* p_algorithmusb;
      93. 	//p_algorithmusb = (void*)(new WindNetDetect());
      94. 	//std::string net_binsusb = "./models/visdrone_1009-opt.bin";
      95. 	//std::string net_parasusb = "./models/visdrone_1009-opt.param";
      96. 	//int init_res = ((WindNetDetect*)p_algorithmusb)->init1(net_binsusb, net_parasusb);
      97. 	//WindNetDetect* tmp = (WindNetDetect*)(p_algorithmusb);
      98.  
      99. 	while (capture.isOpened()) {
      100. 		std::lock_guard mtx_locker(mtx);
      101.  
      102. 		start = clock();
      103. 		if (!capture.read(frameusb)) {
      104. 			break;
      105. 		}
      106. 		//gray = frame;
      107. 		end = clock();
      108. 		std::vector objectsusb;
      109. 		tmp->detect(frameusb, objectsusb);
      110.  
      111. 		for (size_t i = 0; i < objectsusb.size(); i++)
      112. 		{
      113. 			const Object& obj = objectsusb[i];
      114. 			fprintf(stderr, "%d = %.5f at %.2f %.2f %.2f x %.2f\n", obj.label, obj.prob,
      115. 				obj.rect.x, obj.rect.y, obj.rect.width, obj.rect.height);
      116.  
      117. 			cv::rectangle(frameusb, obj.rect, cv::Scalar(255, 0, 0));
      118.  
      119. 			char text[256];
      120. 			//sprintf(text, "%s %.1f%%", class_names[obj.label], obj.prob * 100);
      121. 			sprintf(text, "%s", class_names[obj.label]);
      122.  
      123. 			int baseLine = 0;
      124. 			cv::Size label_size = cv::getTextSize(text, cv::FONT_HERSHEY_SIMPLEX, 0.5, 1, &baseLine);
      125.  
      126. 			int x = obj.rect.x;
      127. 			int y = obj.rect.y - label_size.height - baseLine;
      128. 			if (y < 0)
      129. 				y = 0;
      130. 			if (x + label_size.width > frameusb.cols)
      131. 				x = frameusb.cols - label_size.width;
      132.  
      133. 			cv::rectangle(frameusb, cv::Rect(cv::Point(x, y), cv::Size(label_size.width, label_size.height + baseLine)),
      134. 				cv::Scalar(255, 255, 255), -1);
      135.  
      136. 			cv::putText(frameusb, text, cv::Point(x, y + label_size.height),
      137. 				cv::FONT_HERSHEY_SIMPLEX, 0.5, cv::Scalar(0, 0, 0));
      138. 		}
      139.  
      140. 		//cv::imwrite("./result20.jpg", image);
      141.  
      142. 		cv::imshow("外接摄像头检测1", frameusb);
      143. 		end2 = clock();
      144. 		float rumtime = (float)(end2 - start) / CLOCKS_PER_SEC;
      145. 		std::stringstream buf;
      146. 		buf.precision(3);//����Ĭ�Ͼ���
      147. 		buf.setf(std::ios::fixed);//����С��λ
      148. 		buf << rumtime;
      149. 		std::string strtime;
      150. 		strtime = buf.str();
      151. 		std::cout << "strtime1111 = " << strtime << std::endl;
      152. 		//start = end2;
      153.  
      154.  
      155. 		if (cv::waitKey(5) == 'q') {
      156. 			break;
      157. 		}
      158.  
      159. 	}
      160. 	capture.release();
      161. 	
      162. }
      163.  
      164. int main() {
      165.  
      166. 	void* p_algorithm;
      167. 	p_algorithm = (void*)(new WindNetDetect());
      168. 	std::string net_bins = "./models/visdrone_1009-opt.bin";
      169. 	std::string net_paras = "./models/visdrone_1009-opt.param";
      170. 	int init_res = ((WindNetDetect*)p_algorithm)->init1(net_bins, net_paras);
      171. 	tmp = (WindNetDetect*)(p_algorithm);
      172.  
      173. 	//HANDLE hThread1 = CreateThread(NULL, 0, get_cam1, NULL, 0, NULL);
      174. 	//CloseHandle(hThread1);
      175. 	//HANDLE hThread2 = CreateThread(NULL, 0, get_camusb, NULL, 0, NULL);
      176. 	//CloseHandle(hThread2);
      177.  
      178. 	std::thread thrd_1(get_cam1);
      179. 	std::thread thrd_2(get_camusb);
      180. 	thrd_1.join();
      181. 	thrd_2.join();
      182.  
      183. 	while (true)
      184. 	{
      185. 		std::cout << "Main Thread Display!" << std::endl;
      186. 		Sleep(3000);
      187. 	}
      188. 	return 0;
      189. }
        190.  

        运行上面的代码时，两个函数没有同步运行。如下strtime1111表示一个线程调用的函数，strtime2222表示另一个线程调用的函数，能看出没有同时调用两个函数。
         

         所以需对代码进行如下改进：
         

        1. static std::mutex mutexk;
        2. void get_cam1()
        3. {
        4. 	clock_t start, end, end1, end2;
        5. 	std::string rtsps = "rtsp://admin:bs123456@192.168.1.64:554/h264/ch1/main/av_stream/1";
        6. 	VideoCaptureMT capture(rtsps);
        7. 	cv::Mat frame;
        8. 	cv::namedWindow("ss", 0);
        9.  
        10. 	while (capture.isOpened()) {
        11. 		//pthread_rwlock_rdlock(&rwlock);
        12. 		//std::lock_guard mtx_locker(mtx);
        13.  
        14. 		start = clock();
        15. 		if (!capture.read(frame)) {
        16. 			break;
        17. 		}
        18. 		if (mutexk.try_lock()) {
        19. 			//gray = frame;
        20. 			end = clock();
        21. 			std::vector objects;
        22. 			tmp->detect(frame, objects);
        23.  
        24. 			//tmp->draw_objects(frame, objects);
        25. 			for (size_t i = 0; i < objects.size(); i++)
        26. 			{
        27. 				const Object& obj = objects[i];
        28. 				fprintf(stderr, "%d = %.5f at %.2f %.2f %.2f x %.2f\n", obj.label, obj.prob,
        29. 					obj.rect.x, obj.rect.y, obj.rect.width, obj.rect.height);
        30.  
        31. 				cv::rectangle(frame, obj.rect, cv::Scalar(255, 0, 0));
        32.  
        33. 				char text[256];
        34. 				//sprintf(text, "%s %.1f%%", class_names[obj.label], obj.prob * 100);
        35. 				sprintf(text, "%s", class_names[obj.label]);
        36.  
        37. 				int baseLine = 0;
        38. 				cv::Size label_size = cv::getTextSize(text, cv::FONT_HERSHEY_SIMPLEX, 0.5, 1, &baseLine);
        39.  
        40. 				int x = obj.rect.x;
        41. 				int y = obj.rect.y - label_size.height - baseLine;
        42. 				if (y < 0)
        43. 					y = 0;
        44. 				if (x + label_size.width > frame.cols)
        45. 					x = frame.cols - label_size.width;
        46.  
        47. 				cv::rectangle(frame, cv::Rect(cv::Point(x, y), cv::Size(label_size.width, label_size.height + baseLine)),
        48. 					cv::Scalar(255, 255, 255), -1);
        49.  
        50. 				cv::putText(frame, text, cv::Point(x, y + label_size.height),
        51. 					cv::FONT_HERSHEY_SIMPLEX, 0.5, cv::Scalar(0, 0, 0));
        52. 			}
        53. 			//cv::imwrite("./result20.jpg", image);
        54. 			cv::imshow("ss", frame);
        55.  
        56. 			end2 = clock();
        57. 			float rumtime = (float)(end2 - start) / CLOCKS_PER_SEC;
        58. 			std::stringstream buf;
        59. 			buf.precision(3);//����Ĭ�Ͼ���
        60. 			buf.setf(std::ios::fixed);//����С��λ
        61. 			buf << rumtime;
        62. 			std::string strtime;
        63. 			strtime = buf.str();
        64. 			std::cout << "strtime2222 = " << strtime << std::endl;
        65. 			//start = end2;
        66.  
        67. 			if (cv::waitKey(5) == 'q') {
        68. 				break;
        69. 			}
        70. 			mutexk.unlock();
        71. 		}
        72.  
        73. 	}
        74. 	capture.release();
        75. }
        76.  
        77. void get_camusb()
        78. {
        79. 	//std::lock_guard mtx_locker(mtx);
        80. 	clock_t start, end, end1, end2;
        81.  
        82. 	//std::string rtsps = "rtsp://wowzaec2demo.streamlock.net/vod/mp4:BigBuckBunny_115k.mp4";
        83. 	std::string rtsps = "rtsp://admin:bs123456@192.168.1.64:554/h264/ch1/main/av_stream/1";
        84.  
        85. 	VideoCaptureMT capture(rtsps);
        86.  
        87. 	cv::Mat frameusb;
        88. 	cv::namedWindow("zz1", 0);
        89.  
        90. 	while (capture.isOpened()) {
        91. 		std::lock_guard mtx_locker1(mtx);
        92.  
        93. 		start = clock();
        94. 		if (!capture.read(frameusb)) {
        95. 			break;
        96. 		}
        97. 		if (mutexk.try_lock()) {
        98. 			//gray = frame;
        99. 			end = clock();
        100. 			std::vector objectsusb;
        101. 			tmp->detect(frameusb, objectsusb);
        102.  
        103. 			//tmp->draw_objects(frameusb, objectsusb);
        104.  
        105. 			for (size_t i = 0; i < objectsusb.size(); i++)
        106. 			{
        107. 				const Object& obj = objectsusb[i];
        108. 				fprintf(stderr, "%d = %.5f at %.2f %.2f %.2f x %.2f\n", obj.label, obj.prob,
        109. 					obj.rect.x, obj.rect.y, obj.rect.width, obj.rect.height);
        110.  
        111. 				cv::rectangle(frameusb, obj.rect, cv::Scalar(255, 0, 0));
        112.  
        113. 				char text[256];
        114. 				//sprintf(text, "%s %.1f%%", class_names[obj.label], obj.prob * 100);
        115. 				sprintf(text, "%s", class_names[obj.label]);
        116.  
        117. 				int baseLine = 0;
        118. 				cv::Size label_size = cv::getTextSize(text, cv::FONT_HERSHEY_SIMPLEX, 0.5, 1, &baseLine);
        119.  
        120. 				int x = obj.rect.x;
        121. 				int y = obj.rect.y - label_size.height - baseLine;
        122. 				if (y < 0)
        123. 					y = 0;
        124. 				if (x + label_size.width > frameusb.cols)
        125. 					x = frameusb.cols - label_size.width;
        126.  
        127. 				cv::rectangle(frameusb, cv::Rect(cv::Point(x, y), cv::Size(label_size.width, label_size.height + baseLine)),
        128. 					cv::Scalar(255, 255, 255), -1);
        129.  
        130. 				cv::putText(frameusb, text, cv::Point(x, y + label_size.height),
        131. 					cv::FONT_HERSHEY_SIMPLEX, 0.5, cv::Scalar(0, 0, 0));
        132. 			}
        133.  
        134. 			//cv::imwrite("./result20.jpg", image);
        135.  
        136. 			cv::imshow("zz1", frameusb);
        137.  
        138. 			end2 = clock();
        139.  
        140. 			float rumtime = (float)(end2 - start) / CLOCKS_PER_SEC;
        141. 			std::stringstream buf;
        142. 			buf.precision(3);//����Ĭ�Ͼ���
        143. 			buf.setf(std::ios::fixed);//����С��λ
        144. 			buf << rumtime;
        145. 			std::string strtime;
        146. 			strtime = buf.str();
        147. 			std::cout << "strtime1111 = " << strtime << std::endl;
        148. 			//start = end2;
        149.  
        150.  
        151. 			if (cv::waitKey(5) == 'q') {
        152. 				break;
        153. 			}
        154. 			mutexk.unlock();
        155. 		}
        156. 		
        157. 	}
        158. 	capture.release();
        159.  
        160. }
        161.  
        162.  
        163. int main() {
        164. 	
        165.  
        166. 	void* p_algorithm;
        167. 	p_algorithm = (void*)(new WindNetDetect());
        168. 	std::string net_bins = "./models/visdrone_1009-opt.bin";
        169. 	std::string net_paras = "./models/visdrone_1009-opt.param";
        170. 	int init_res = ((WindNetDetect*)p_algorithm)->init1(net_bins, net_paras);
        171. 	tmp = (WindNetDetect*)(p_algorithm);
        172.  
        173. 	std::thread thrd_1(get_cam1);
        174. 	std::thread thrd_2(get_camusb);
        175. 	thrd_1.join();
        176. 	thrd_2.join();
        177.  
        178. 	while (true)
        179. 	{
        180. 		std::cout << "Main Thread Display!" << std::endl;
        181. 		Sleep(3000);
        182. 	}
        183. 	return 0;
        184. }
          185.  

                   使用多线线程调用多个函数同步执行模板如下：
           

          1. #include 
          2. #include 
          3. static std::mutex mutexk;
          4. void func1() {
          5. 	while (capture1.isOpened()) {
          6. 		if (mutexk.try_lock()) {
          7. 			//我的算法
          8. 			my_func1();
          9.             mutexk.unlock();
          10. 		}
          11. 		
          12. 	}
          13. }
          14. void func2() {
          15. 	while (capture2.isOpened()) {
          16. 		if (mutexk.try_lock()) {
          17. 			//我的算法
          18. 			my_func2();
          19.             mutexk.unlock();
          20. 		}
          21. 		
          22. 	}
          23. }
          24.  
          25. int main() {
          26. 	std::thread thrd_1(func1);
          27. 	std::thread thrd_2(func2);
          28. 	thrd_1.join();
          29. 	thrd_2.join();
          30. 	return 0;
          31. }
           

          在ubuntu中c++opencv多线程显示图片时出现Gdk-WARNING **: xx: Fatal IO error
           

           解决办法：
           

          1、sudo apt install libx11-dev
           

          2、在代码中添加头文件#include 
           

          3、在创建线程之前添加XInitThreads()
           

          4、在编译的时候需要添加-lX11 
           

          参考链接：OpenCV视频流的C++多线程处理方式_hlld26的博客-CSDN博客_opencv 多线程
          
                
                    
                

                
        185. 

                    相关阅读:
          
                    
如何构建城市经济大脑分析指标框架？六大分析主题                            
          
【SpringSecurity】BCrypt密码加密和解密 一文学会使用BCryptPasswordEncoder                            
          
Argo CD 保姆级入门教程                            
          
内存泄露详细介绍                            
          
基于udp协议的网络通信(windows客户端版+简易聊天室版),重定向到终端                            
          
JavaScript 67 JavaScript HTML DOM 67.11 JavaScript HTML DOM 导航                            
          
Docker 使用                            
          
基于SSM SpringBoot vue个人博客网站                            
          
【EMC专题】案例：PCB走线参考平面不完整导致辐射超标                            
          
基于51单片机的羽毛球计分器设计                            
          
                              
                
          186. 
                
        186. 
                    原文地址：https://blog.csdn.net/zk_ken/article/details/127802063
                
          187.