并发计算二三阶矩阵

矩阵的计算随着阶数的上升会越发的复杂，假如使用C语言直接计算，按照C语言按部执行的特性，那将会消耗大量的时间，所以本文计划将矩阵公式分割为几个小块，使用并发的方式来同时将各个小块计算出来从而节省时间（误，单纯是作者为了复习并发的知识而已）

二三阶矩阵计算的C语言实现

我们首先要判断用户输入的是几阶矩阵，简单的判断思路分为两中，一是根据用户输入的数字数来开方，二是根据用户输入的回车数量来判断，本文选择根据回车数量来判断；

在不进行并发优化前，我们只需要根据矩阵阶数来按照公式计算即可，值得注意的是，若选用getchar函数来获取字符，需要对获取的字符进行转化，下述代码进行了简单的-48处理（懒ing）

cpp 复制代码

#include<stdio.h>
#include<string.h>
int main(void)
{
	int matrixadd=0;
	int matrixflag=0;
	int icnt=0;
	int data[12]={0};
	printf("please input your matrix\r\n");
	for(icnt=0;icnt<12;icnt++)
	{
		data[icnt]=getchar();
		if(data[icnt]==' ')
		{
			icnt--;
		}
		else
		{
			if(data[2]=='\n' && data[5]=='\n')
			{
				matrixflag=4;
				break;
			}
			else if(data[3]=='\n' && data[7]=='\n' && data[11]=='\n')
			{
				matrixflag=9;
			}
			else
			{
				;
			}
		}
	}
	for(icnt=0;icnt<12;icnt++)
	{
		data[icnt]=data[icnt]-48;
	}
	if(matrixflag==4)
	{
		matrixadd=data[0]*data[4]-data[1]*data[3];
	}
	else if(matrixflag==9)
	{
		matrixadd=(data[0]*data[5]*data[10])+(data[1]*data[6]*data[8])+(data[2]*data[4]*data[9])-(data[0]*data[6]*data[9])-(data[2]*data[5]*data[8])-(data[10]*data[1]*data[4]);
	}
	else 
	{
		printf("please input agent\n");
		return 0;
	}
	printf("the matrixadd is %d \n",matrixadd);
}

上述代码中最不和谐的地方就是三阶矩阵的计算，假如阶数继续上升，那代码的执行效率将稳步下降，所以接下来将用并发的方式来脱裤子放屁式的把他优化了：

cpp 复制代码

#include<stdio.h>
#include<string.h>
#include<pthread.h>
#include<unistd.h>
int matrixadd=1;
int data[12]={0};
void* culculate(void* arg)
{
	matrixadd=(data[0]*data[5]*data[10])+(data[1]*data[6]*data[8])+(data[2]*data[4]*data[9])-(data[0]*data[6]*data[9])-(data[2]*data[5]*data[8])-(data[10]*data[1]*data[4]);
}
int main(void)
{
	void *ret=NULL;
	pthread_t a;
	int matrixflag=0;
	int icnt=0;
	printf("please input your matrix\r\n");
	for(icnt=0;icnt<12;icnt++)
	{
		data[icnt]=getchar();
		if(data[icnt]==' ')
		{
			icnt--;
		}
		else
		{
			if(data[2]=='\n' && data[5]=='\n')
			{
				matrixflag=4;
				break;
			}
			else if(data[3]=='\n' && data[7]=='\n' && data[11]=='\n')
			{
				matrixflag=9;
			}
			else
			{
				;
			}
		}
	}
	for(icnt=0;icnt<12;icnt++)
	{
		data[icnt]=data[icnt]-48;
	}
	if(matrixflag==4)
	{
		matrixadd=data[0]*data[4]-data[1]*data[3];
	}
	else if(matrixflag==9)
	{
		pthread_create(&a,NULL,culculate,NULL);
		if(pthread_create(&a,NULL,culculate,NULL)!=0)
		{
			printf("failed to vreate thread\n");
		}
		sleep(1);
	}
	else 
	{
		printf("please input agent\n");
		return 0;
	}
	printf("the matrixadd is %d \n",matrixadd);
	pthread_exit(ret);
	pthread_join(a,ret);
}

上述代码的效率在阶数少的时候明显不如一开始的，甚至运行时间还延长了不少，除了加了sleep的原因外（为了在打印最终结果的时候，另一个线程执行完毕），创建线程也需要时间，所以这个代码只是用于娱乐，仅仅作为复习线程知识用，但计算大量数据时，这种思路无疑真的会优化效率，所以也不能说一无是处（233333333333）