1、关于多线性进行全局变量的使用的时候为什么需要加锁？

a、在多线程中对全局变量进行处理的时候，如果涉及到在线程中对全局变量进行赋值的话，则需要进行加锁。

如果不加锁的话，容易导致全局变量在某个线程中被修改后，影响另一线程的数据处理。

b、全局变量不加锁主要是为了数据处理的正正确性，而不是为了防止导致多个线程同时操作同一个数据时出现程序崩溃。因为这种情况是不会产生的。

下面是一个多线程对多个全局变量进行赋值操作和读取操作。其都不会出现程序崩溃现象下面c、的代码也可以看出其不会导致崩溃。

c、下面是关于线程的join和detach的区别：

int pthread_detach(pthread_t tid); 若成功则返回0，若出错则为非零。

pthread_detach用于分离可结合线程tid。线程能够通过以pthread_self()为参数的pthread_detach调用来分离它们自己。

如果一个可结合线程结束运行但没有被join，则它的状态类似于进程中的Zombie Process，即还有一部分资源没有被回收，所以创建线程者应该调用pthread_join来等待线程运行结束，并可得到线程的退出代码，回收其资源。

由于调用pthread_join后，如果该线程没有运行结束，调用者会被阻塞，在有些情况下我们并不希望如此。例如，在Web服务器中当主线程为每个新来的连接请求创建一个子线程进行处理的时候，主线程并不希望因为调用pthread_join而阻塞（因为还要继续处理之后到来的连接请求），这时可以在子线程中加入代码

pthread_detach(pthread_self())

或者父线程调用

pthread_detach(thread_id)（非阻塞，可立即返回）

这将该子线程的状态设置为分离的（detached），如此一来，该线程运行结束后会自动释放所有资源。

注意： 第一：如果使用detach要小心点，就是如果线程的执行时间太久，会导致主线程会在上次子线程还没执行完就带着新数据或者在新一轮里改变了子线程里的一些全局变量。这是就需要记得加锁，来防止数据不一致。第二：如果detach后面的代码是需要子线程执行完后的处理结果的则不能使用detach方式，因为子线程还没有处理后结果，后面代码就进行结果读取的话，要么导致内存泄漏，要么是结果数据不对。

下面是使用pthread_join创建线程。

#include"3rdparty\include\pthread.h"
#include"opencv2\opencv.hpp"
using namespace cv;
int* hhnum; Mat img;
int threadnums = 6;
void* jia(void*params)
	int args = *(int*)params;
	free(params);
	while (true)
	    img = imread("3.jpg");
		*hhnum =args;
		std::cout << *hhnum << std::endl;
		imwrite("4.jpg", img);
void main()
	hhnum = new int[1];
	pthread_t *threads = (pthread_t*)calloc(threadnums, sizeof(pthread_t));
	for (size_t i = 0; i < threadnums; i++)
		int*ptr = (int*)calloc(1, sizeof(int));
		*ptr = i;
		pthread_t thread;
		pthread_create(&thread, 0, jia, ptr);
		threads[i] = thread;
	for (size_t j = 0; j < threadnums; j++)
			pthread_join(threads[j], 0); //这个创建的线程是阻塞式的，只有当所有的线程结束后，程序才会往下执行。
		catch (Exception e)
			int i = 0;
  注意：这种这线程是不可分离线程，其需要等待所有的线程执行完成才可以继续执行。上面的代码会一直阻塞在主线程上。其一般跟joinable配合使用。其中joinable：代表该线程是否是可执行线程，其true代表可执行，false代表不可执行，不可执行意味着改线程要么没被创建，要么已经带有join是否相关资源了。其配合使用代码如下：
 
					if (t_cap.joinable()) {
						t_cap.join();
						++fps_cap_counter;
						cur_frame = cap_frame.clone();
  注意：在调用碗join()后，其中joinable(）就返回的就是false了、
 
下面使用pthread_detach来创建可分离线程。
 
#include"3rdparty\include\pthread.h"
#include"opencv2\opencv.hpp"
using namespace cv;
int* hhnum; Mat img;
int threadnums = 10;
void* jia(void*params)
	int args = *(int*)params;
	free(params);
	cvNamedWindow("krk");
	for (size_t i = 0; i < args; i++)
		img = imread("3.jpg");
		*hhnum = args;
		//std::cout << *hhnum << std::endl;
		imwrite("4.jpg", img);
		cvWaitKey(100 - i);
		if (args == 3)
			while (true)
	return (void*)8;
void main()
	hhnum = new int[1];
	cvNamedWindow("kk");
	pthread_t *threads = (pthread_t*)calloc(threadnums, sizeof(pthread_t));
	for (size_t i = 0; i < threadnums; i++)
		int*ptr = (int*)calloc(1, sizeof(int));
		*ptr = i;
		pthread_t thread;
		pthread_create(&thread, 0, jia, ptr);
		threads[i] = thread;
	for (size_t j = 0; j < threadnums; j++)
			pthread_detach(threads[j]);
			std::cout << j << std::endl;
		catch (Exception e)
			int i = 0;
	waitKey(0);
其输出结果是：
 
注意：其是立即返回的。并且但线程执行完后，系统会自动回收线程资源。其中第三个线程还一直在执行着。
 
2、pthread、openomp进行多线程加速：
 
其中pthread实现多线程比openomp麻烦，但是其加速的速度比openomp的快；而且pthread实现的多线程的限制没有openomp那么多。
 
关于两个使用的个人见解：
 
a、pthread适合实现代码比较多的地方。而openomp适合代码比较少的地方特别适合多重for循环的地方。
 
b、pthread适合一些openomp无法实现多线程的地方。例如一些具有bread代码的地方，使用openomp会报错。
 
下面是根据seataface实现openomp的例子：
 
	clock_t start, finish;
	float duration;
	Mat imgg = imread("13.jpg");
	for (size_t i = 0; i < 90; i++)
		auto starts = chrono::system_clock::now();
//openomp实现格式#pragma omp 指令...; parallel表示这段代码将被多个线程并行执行。
//num_threads 指定并行域内的线程的数目。
#pragma omp parallel num_threads(4)
//用来取消栅障。其栅障是用于线程同步的一种方法，线程遇到栅障时必须等待，知道并行的所有的线程都到达同一个点。
#pragma omp for nowait
		for (int32_t i = 0; i < 1; i++)
			for (int32_t j = 0; j < imgg.cols; j++)
				imgg.at<Vec3b>(i, j)[0] = imgg.at<Vec3b>(i, j)[0] * 0.01;
				imgg.at<Vec3b>(i, j)[1] = imgg.at<Vec3b>(i, j)[1] * 0.01;
				imgg.at<Vec3b>(i, j)[2] = imgg.at<Vec3b>(i, j)[2] * 0.01;
	auto finishs = chrono::steady_clock::now();
	cout << "处理时间为：" << (short)chrono::duration_cast<chrono::milliseconds> (finishs - starts).count() << endl;
下面介绍openomp的知识：
 
其中一些库函数：
 
      函数原型                                         功能
 
      int omp_get_num_procs(void)      返回当前可用的处理器个数
 
      int omp_get_num_threads(void)  返回当前并行区域中活动线程的个数，如果在并行区域外部调用，返回1
 
      int omp_get_thread_num(void)    返回当前的线程号（omp_get_thread_ID更好一些）
 
      int omp_set_num_threads(void)   设置进入并行区域时，将要创建的线程个数
 
  函数声明                                                                   功能
 
  void omp_init_lock(omp_lock*)                               初始化互斥器
 
  void omp_destroy_lock(omp_lock*)                        销毁互斥器
 
  void omp_set_lock(omp_lock*)                               获得互斥器
 
  void omp_unset_lock(omp_lock*)                           释放互斥器
 
  void omp_test_lock(omp_lock*)                              试图获得互斥器，如果获得成功则返回true，否则返回false
 
隐式栅障(Barrier)是OpenMP用于线程同步的一种方法。线程遇到栅障时必须等待，知道并行的所有线程都到达同一点。
 
nowait：是取消栅障的指令。
 
OpenMP基本概念：
 OpenMP是一种用于共享内存并行系统的多线程程序设计方案，支持的编程语言包括C、C++和Fortran。OpenMP提供了对并行算法的高层抽象描述，特别适合在多核CPU机器上的并行程序设计。编译器根据程序中添加的pragma指令，自动将程序并行处理，使用OpenMP降低了并行编程的难度和复杂度。当编译器不支持OpenMP时，程序会退化成普通（串行）程序。程序中已有的OpenMP指令不会影响程序的正常编译运行。在VS中启用OpenMP很简单，很多主流的编译环境都内置了OpenMP。在项目上右键->属性->配置属性->C/C++->语言->OpenMP支持，选择“是”即可。
 
OpenMP执行模式：
 OpenMP采用fork-join的执行模式。开始的时候只存在一个主线程，当需要进行并行计算的时候，派生出若干个分支线程来执行并行任务。当并行代码执行完成之后，分支线程会合，并把控制流程交给单独的主线程。
 
一个典型的fork-join执行模型的示意图如下：
 
OpenMP编程模型以线程为基础，通过编译制导指令制导并行化，有三种编程要素可以实现并行化控制，他们分别是编译制导、API函数集和环境变量。
3、使用SSE计算单元进行算法加速：
 
//计算宇炫距离适合很合适
float simd_dot(const float* x, const float* y, const long& len) {
	float inner_prod = 0.0f;
	__m128 X, Y; // 128-bit values
	__m128 acc = _mm_setzero_ps(); //  初始化为 (0, 0, 0, 0)
	float temp[4];
	long i;
	//这里是要计算x，y之间的对应位相乘后相加的总结果。
	for (i = 0; i + 4 < len; i += 4) {
		X = _mm_loadu_ps(x + i); // 这里使用的是SSE指令集加速，128位可以加载四个float值。
		Y = _mm_loadu_ps(y + i);
		acc = _mm_add_ps(acc, _mm_mul_ps(X, Y));
	_mm_storeu_ps(&temp[0], acc); // 存储到一个数组里
	inner_prod = temp[0] + temp[1] + temp[2] + temp[3];
	// 累加剩下的值
	for (; i < len; ++i) {
		inner_prod += x[i] * y[i];
	return inner_prod;
注意：这里的SSE的指令集操作也是有开销的，如果len长度不大，就可以不使用sse加速。
 
                    1、关于多线性进行全局变量的使用的时候为什么需要加锁？a、在多线程中对全局变量进行处理的时候，如果涉及到在线程中对全局变量进行赋值的话，则需要进行加锁。如果不加锁的话，容易导致全局变量在某个线程中被修改后，影响另一线程的数据处理。b、全局变量不加锁主要是为了数据处理的正正确性，而不是为了防止导致多个线程同时操作同一个数据时出现程序崩溃。因为这种情况是不会产生的。下面是一个多线程对多...
在前期基础知识储备以后，让我们正式进入利用多线程实现程序加速的环节
将原始计算过程拆分为多个过程。例如计算五亿次加法过程。我们可以将其分为两个过程，从零加到两万五，再从两万五加到五万。
下面的程序分别展示用两个线程和单个线程实现五亿次加法过程。measure测量时间函数已经在上一章节中详述，不再重复。
int main() {
	long times = 50000000...
				
主要介绍MP(Matching Pursuits)算法和OMP(Orthogonal Matching Pursuit)算法[1]，这两个算法虽然在90年代初就提出来了，但作为经典的算法，国内文献(可能有我没有搜索到)都仅描述了算法步骤和简单的应用，并未对其进行详尽的分析，国外的文献还是分析的很透彻，所以我结合自己的理解，来分析一下写到博客里，算作笔记。
1. 信号的稀疏表示(sparse re
avx256是x86cpu架构下实现SIMD（单指令多数据）的指令集。它能够利用cpu内部256bit的寄存器，同时对4位double或8位int类型的数操作，达到很好的加速效果。这里通过一个计算π\piπ的实例来展示其威力：
π=4∫0111+x2dx
\pi = 4\int_0^1\frac{1}{1+x^2}dx
π=4∫01​1+x21​dx
linux系统下可以通过如下命令查看电脑是否支持avx256指令集：
cat /proc/cpuinfo | grep flags
sse4就表示
				
我们在系列6里面已经说了多线程(使用std::thread库)，然而项目里面竟然还用到了openmp，不得已只能看下。
1. 入门介绍
openmp是由一系列#paragma指令组成，这些指令控制如何多线程的执行程序。另外，即使编译器不支持omp，程序也也能够正常运行，只是程序不会多线程并行运行。
首先要在cmake中添加上openmp，cmake3.9之后内置了openmp，按照下述语句写即可：
然后看一个简单例子：
2. 语法解释
2.1 紧跟for
omp中的for指令用于告诉编译器，拆分接下来的
                linux下lpython查版本信息，ln进行python软连接、find、which进行环境变量文件查找、ps进行进程查看、/usr/local/为软件安装主目录-new
                    CSDN-Ada助手: 
                    哇, 你的文章质量真不错，值得学习！不过这么高质量的文章, 还值得进一步提升, 以下的改进点你可以参考下: (1)使用更多的站内链接；(2)增加条理清晰的目录；(3)使用标准目录。
                NEW-在window上使用CMakeLists.txt修建工程注意问题、cmake减少工程环境变量配置的工作例如opencv、libtorch的工程配置
                    CSDN-Ada助手: 
                    哇, 你的文章质量真不错，值得学习！不过这么高质量的文章, 还值得进一步提升, 以下的改进点你可以参考下: (1)增加条理清晰的目录；(2)使用标准目录。