首先要确保这些请求不是同一请求：
再测试这个问题的时候，遇到了一个问题，就是同一浏览器（谷歌），多次测试（开了多个tab页），发现多次请求同一方法，执行时顺序执行，即第一个请求执行完毕，第二个请求才开始执行
当打开QQ浏览器时，才能并发执行
此问题，其实还是session问题导致的，同一浏览器多次请求同一个方法（域名、地址都相同），会被认为是同一个用户多次请求，因此是顺序执行；当用其他浏览器打开时，session不一样了，会认为是其他用户登录系统执行操作，因此是并发执行代码
例图：

有个小伙子告诉我，一个页面上同时开启多个ajax，向后台请求数据，会被堵塞。

“因为是同一个会话。但如果在控制器上加上这个特性就可以了”，小伙子说。
    //session只读，避免同一会话中session锁导致请求阻塞
    [SessionState(System.Web.SessionState.SessionStateBehavior.ReadOnly)]
    public class CxController : BaseLT.Web.UserControllerBase
    {
    。。。。
    }

经测试，还真是。如果没有这个特性，多个ajax请求到了后台，原本是并发的，结果变成了队列，一个接一个地完成。如果加上，则是并行完成。

个中原因，可以看以下参考资料：

ASP.net Session阻塞、Session锁、MVC Action请求阻塞问题
“HttpSessionState来自于HttpModule的SessionStateModule。在每次请求处理过程中，HttpApplication的请求的处理管道中会检查当前请求的处理程序是否实现了接口IRequiresSessionState，如果实现的话，那么SessionStateModule将为这个请求分配HttpSessionState。同时SessionStateModule还负责SessionID的生成、Cookieless会话管理、从外部状态提供程序中检索会话数据以及将数据绑定到请求的调用上下文。

如果页面请求设置一个读取器锁定，同一会话中同时处理的其他请求将无法更新会话状态，但是至少可以进行读取。如果页面请求为会话状态设置一个写入锁，那么所有其他页面都被阻止，无论他们是否要读取或写入内容。例如，如果同时有两段程序视图在同一个Session中写入内容，一段程序必须等到另一段程序完成后才能写入。在AJAX程序设计中，必须注意这种情况的发生。”
我只想说，后生可畏。

1.排查问题：

     首先运行一个ajax请求看，请求返回数据是否正常；如果不正常说明sql或者后台代码有问题；

     如果没问题：说明是发送多个ajax请求时，导致数据错乱；

2.解决问题:

    a.在第一个ajax请求的回调函数中，调用下一个ajax请求（不建议）

    b.在控制层使用synchronized（一个线程访问一个对象中的synchronized(this)同步代码块时，其他试图访问该对象的线程将被阻塞。）

synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种：

1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；

2. 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；

3. 修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；

4. 修改一个类，其作用的范围是synchronized后面括号括起来的部分，作用主的对象是这个类的所有对象。

 

        如果实现一客户端与服务器的交互比较容易(直接用TCP的编程流程就可以实现，只是这样写出的程序只能是一个客户端交互释放连接后其他客户端才可以与服务器交互 )，但是要实现多个客户端同时与同一服务器的交互就相对复杂一点。

我们先给出服务器处理同一客户端的多次访问的伪代码：

                           

要实现多个客户端同时与同一服务器的交互，就要求服务器与客户端的交互要并发处理。我们就想到用多进程，或者多线程来实现。以下我们分别用多进程和多线程来实现多个客户端同时与同一服务器的交互。

多进程：启动多个进程，每个进程执行和一个客户端的交互。

  1. 父进程完成与客户端的连接工作，随后创建子进程，子进程与客户端具体交互。

  2.父进程需不需要把文件描述符传递给子进程？（不需要，因为在fork之前打开的文件描述符，子进程会继承父进程打开的文件描述符。）

  3.父进程需不需要关闭文件描述符？（需要，父进程关闭文件描述符并没有断开连接，只是将PCB中的struct file中的引用计数-1，等子进程也关闭文件描述符时才真正断开连接。而只有子进程关闭文件描述符父进程不关闭文件描述符，系统就会一直为其维护这一文件描述符，会造成资源的浪费。）

  4.防止僵尸进程，需要修改信号的响应方式。

具体代码如下：

服务器端：

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<string.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<pthread.h>
#include<signal.h>

void communication(int a)
{
	while(1)//一个客户端与服务器多次交互
	{
	    char buff[128]={0};
	    int n=recv(a,buff,127,0);
	    if(n<=0)
	    {
		    close(a);//关闭子进程的文件描述符
		    printf("One client over\n");
		    break;
	     }
	    printf("%d：%s\n",a,buff);
	    send(a,"OK",2,0);
	}
}

void fun(int sig)
{
    wait(NULL);
}
int main()
{
	signal(SIGCHLD,fun);//防止僵尸进程
	int sockfd=socket(PF_INET,SOCK_STREAM,0);
	assert(-1!=sockfd);

	struct sockaddr_in ser,cli;
	ser.sin_family=AF_INET;
	ser.sin_port=htons(6000);
	ser.sin_addr.s_addr=inet_addr("127.0.0.1");
	int res=bind(sockfd,(struct sockaddr*)&ser,sizeof(ser));
	assert(-1!=res);

	listen(sockfd,5);

	while(1)//保证服务器可以与多个客户端交互
	{
		int len=sizeof(cli);
		int n=accept(sockfd,(struct sockaddr*)&cli,&len);
		if(n<0)
		{
			printf("link error\n");
			continue;
		}

	    pid_t m=fork();
		assert(m!=-1);
		if(m==0)
		{
			communication(n);//与客户端交互
			exit(0);//结束子进程，避免子进程再次进入while循环
		}
		else
		{
			close(n);//关闭父进程的文件描述符
		}
	}
    close(sockfd);
}


客户端：

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<string.h>
#include<sys/socket.h>
#include<sys/types.h>
#include<arpa/inet.h>
#include<netinet/in.h>

int main()
{
	int sockfd = socket(PF_INET,SOCK_STREAM,0);
	assert(-1!=sockfd);

	struct sockaddr_in ser,cli;
	memset(&ser,0,sizeof(ser));
	ser.sin_family=AF_INET;
	ser.sin_port=htons(6000);
	ser.sin_addr.s_addr=inet_addr("127.0.0.1");
	int res=connect(sockfd,(struct sockaddr*)&ser,sizeof(ser));
	assert(res!=-1);

	while(1)
	{
		printf("Please input:");
		fflush(stdout);
		char buff[128]={0};
		fgets(buff,127,stdin);
		buff[strlen(buff)-1]=0;

		if(strncmp(buff,"end",3)==0)
		{
		    break;
		}
		send(sockfd,buff,strlen(buff),0);

		memset(buff,0,sizeof(buff));
		recv(sockfd,buff,127,0);
		printf("%s\n",buff);
	}
	close(sockfd);
}


运行结果如下：

客户端1：



客户端2：



服务器端：



我们可以看到两个客户端的文件描述符是一样的，所以能通过文件描述符来判断是否是同一个客户端连接，需要用netstat -natp来查看客户端的ip和端口（地址对）来确定客户端。

多线程：启动多个线程，每个线程执行和一个客户端的交互。

 1. 主线程完成与客户端的连接工作，函数线程与客户端具体交互。

 2.函数线程怎么拿到主线程的文件描述符？（创建线程时，以值传递的形式传递给函数线程，即pthread_create的参数）

 3.主线程需不需要关闭文件描述符？（文件描述符是PCB中struct file*数组的下标，同进程的多个线程共享PCB，故主线程不需要关闭文件描述符。只要有一个线程关闭文件描述符，就直接关闭了与客户端的通讯）

代码实现如下：

服务器端：

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<string.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<pthread.h>

void* communication(void* arg);

int main()
{
	int sockfd=socket(PF_INET,SOCK_STREAM,0);
	assert(-1!=sockfd);

	struct sockaddr_in ser,cli;
	ser.sin_family=AF_INET;
	ser.sin_port=htons(6000);
	ser.sin_addr.s_addr=inet_addr("127.0.0.1");
	int res=bind(sockfd,(struct sockaddr*)&ser,sizeof(ser));
	assert(-1!=res);

	listen(sockfd,5);

	while(1)//保证服务器可以连接多个客户端
	{
		int len=sizeof(cli);
		int c=accept(sockfd,(struct sockaddr*)&cli,&len);
        if(c<0)
        {
            printf("link error\n");
            continue;
        }

		pthread_t id;
		int n=pthread_create(&id,NULL,communication,(void*)c);//创建线程，将文件描述符强转为void*，此处只能是值传递，地址传递的话，可能函数线程还没拿到该地址的值，就被主线程更改
		assert(n==0);
	}
    close(sockfd);
}

void* communication(void* arg)//函数线程完成与客户端的交互
{
	while(1)//实现与一个客户端的多次交互
	{
	    char buff[128]={0};
	    int c=(int)arg;//将文件描述符转回int型
	    int n=recv(c,buff,127,0);
	    if(n<=0)
	    {
			close(c);
			printf("%d client over\n",c);
			break;
	    }
	    printf("%d:%s\n",c,buff);

		send(c,"OK",2,0);
	}
}

客户端yu多进程的客户端相同。

运行结果如下：

客户端1：



客户端2：



服务器端：



多线程的一个缺点：一个进程PCB中struct file*数组的大小的确定的，所以能连接的客户端的个数比较有限。

多进程与多线程的选择？？

多进程和多线程各有利弊，我们需要根据具体业务需求来选择使用哪一种。

我们从以下五个方面对多进程和多线程进行比较：

编程角度：多线程代码实现简单，控制也简单一些。
	
占据资源：多进程比多线程占据的资源多。
	
切换速度：进程CPU调度时比较慢，故多进程比多线程慢。
	
资源共享：线程间比进程间共享资源多。
	
安全性：进程比线程安全，因为线程共享的资源多，而进程之间是相互独立的。
	
能够创建的个数：linux中进程中能够创建的线程数量相比于系统能够创建的进程数量少得多。