tanyufeng_521

[精通WindowsSocket网络开发-基于VC++实现]第五章——非阻塞模式开发

套接字的非阻塞模式是指套接字在执行操作时，调用的函数不管操作是否完成都会立即返回的工作模式。非阻塞套接字在处理同时建立的多个连接，发送和接收的数据量不均，时间不定等方面具有明显的优势。但这种套接字在使用上存在一定难度。本章讲述套接字的非阻塞模式及其一个远程算数运算套接字程序。

套接字的非阻塞模式

所有windows平台都支持套接字以阻塞模式和非阻塞模式的方式工作。

非阻塞模式

把套接字设置为非阻塞模式，即通知系统内核：在调用WindowsSocketsAPI时，不要让线程随眠，而应该让函数理解返回。在返回时，该函数返回一个错误代码。一个非阻塞模式套接字多次调用recv()的过程如上。前3次调用recv()函数时，内核函数还没有准备好。因此，该函数理解返回WSAEWOULDBLOCK错误代码。第4次调用recv()函数时，数据已经准备好，被负责到应用程序的缓冲区中，recv()返回成功指示，应用程序开始处理数据。

设置套接字的非阻塞模式

当使用socket(),WSASocket()创建套接字时，默认都是阻塞的。在创建套接字之后，通过调用ioctlsocket()，将该套接字设置为非阻塞模式。

套接字设置为非阻塞模式后，在调用WindowsSocketsAPI函数时，调用函数会立即返回。大多数情况下，这些函数调用都会调用“失败”，并返回WSAEWOULDBLOCK错误代码。说明请求的操作在调用期间内没有时间完成。通常，应用程序需要重复调用该函数，直到获得成功返回代码。

WSAEWOULDBLOCK的含义
函数名	说明
accept(),WSAAcept()	应用程序没有接收到连接请求
recv(),WSARecv(),recvfrom(),WSARecvfrom()	接收缓冲区没有收到数据
send(),WSASend(),sendto(),WSASendto()	发送缓冲区此时不可用
connect(),WSAConnect()	连接未能立即完成
closesocket()	通常情况下意味着应用程序使用SO_LINGER选项并且设置一个非零的超时值，调用了setsocketopt()

需要说明的是并非所有的WindowsSocketsAPI在非阻塞模式下调用，都会返回WSEWOULDBLOCK错误。eg:bind(),listen()。

要将套接字设置为非阻塞模式，除了使用ioctlsocket()函数之外，还可以使用WSAAsyncSelect()(第7章讲解)，WSAEventselect()(第8章讲解)。当调用该函数时，套接字会自动地设置为非阻塞方式。

非阻塞模式套接字的优势和不足

由于使用非阻塞套接字在调用函数时，会经常返回WSAEWOULDBLOCK错误。所以在任何时候，都应仔细检查返回代码，并做好应对“失败”的准备。应用程序连续不断的调用这个函数，直到它返回成功指示为止。本章程序清单中，在While循环体内不断的调用recv(),以读入1024个字节的数据。这种做法很浪费系统资源。

有人使用MSG_PEEK标志调用recv()查看缓冲区中是否有数据可读。同样，这种方法也不好，因为该做法对系统造成的开销是很大的，并且应用程序至少要调用recv()两次，才能实际地读入数据。较好的做法是，使用套接字的“I/O模型”(第6,7,8,9,10章来讲解)来判断非阻塞套接字是否可读可写。

非阻塞模式套接字与阻塞套接字相比，使用较复杂。使用非阻塞模式套接字，需要编写更多的代码，以便在每个WindowsSocketAPI函数调用中，对收到的WSAEWOULDBLOCK错误进行处理。因此，非阻塞套接字便显得有些难于使用。

但是，非阻塞套接字在控制建立的多个连接，在数据的收发量不均，时间不定等方面，明显具有优势。通常情况下，可考虑使用套接字的“I/O模型”，它有助于应用程序通过异步方法，同时对一个或多个套接字的通信加以管理。

远程算数运算程序

本程序实现一个可以同时为多个客户端提供服务的远程算数运算程序。客户端和服务器端都使用非阻塞套接字。

NoBlockServer

client.h

[cpp] view plain copy print ?

#pragma once
#include <WinSock2.h>
#define TIMEFOR_THREAD_CLIENT 500//线程睡眠时间
#define MAX_NUM_CLIENT 10//接受的客户端连接最多数量
#define MAX_NUM_BUF 48//缓冲区的最大长度
#define INVALID_OPERATOR 1 //无效的操作符
#define INVALID_NUM 2 //分母为0
typedef struct _head//数据包包头结构，该结构在win32下位4byte
{
char type;//类型
unsigned short len;//数据包长度(包括头的长度)
}hdr,*phdr;
#define HEADERLEN (sizeof(hdr))//头长度
typedef struct _data//数据包中数据结构
{
char buf[MAX_NUM_BUF];//数据
}DATABUF,*pDataBuf;
//数据包：包头(类型[2byte]+长度[2byte])+数据；
class Client
{
public:
Client(const SOCKET sClient,const sockaddr_in &addrClient);
virtual ~Client(void);
public:
BOOL StartRunning();//创建和接收数据线程
void HandleData(const char* pExpr);//计算表达式
BOOL IsConning()//是否连接存在
{
return m_bConning;
}
void DisConning()//断开与客户端的连接
{
m_bConning=FALSE;
}
BOOL IsExit()//发送和接收线程是否已经退出
{
return m_bExit;
}
public:
static DWORD _stdcall RecvDataThread(void* pParam);//接收客户端数据
static DWORD _stdcall SendDataThread(void* pParam);//向客户端发送数据
public:
SOCKET m_socket;//套接字
sockaddr_in m_addr;//接收客户端的地址
private:
DATABUF m_data;//客户端数据；接收线程和发送线程公用该数据变量
HANDLE m_hEvent;//事件对象。当接收线程完成算数表达式的计数后使用该事件对象，通知发送线程发送数据
HANDLE m_hThreadSend;//发送数据线程句柄
HANDLE m_hThreadRecv;//接收数据线程句柄
CRITICAL_SECTION m_cs;//临界区对象。确保接收数据线程和发送数据线程对m_data数据成员的互斥访问
BOOL m_bConning;//客户端连接状态
BOOL m_bExit;//线程退出
};

#pragma once
#include <WinSock2.h>
#define  TIMEFOR_THREAD_CLIENT 500//线程睡眠时间
#define  MAX_NUM_CLIENT 10//接受的客户端连接最多数量
#define  MAX_NUM_BUF 48//缓冲区的最大长度
#define  INVALID_OPERATOR 1 //无效的操作符
#define  INVALID_NUM 2 //分母为0
typedef struct _head//数据包包头结构，该结构在win32下位4byte
{
    char type;//类型
    unsigned short len;//数据包长度(包括头的长度)
}hdr,*phdr;
#define  HEADERLEN (sizeof(hdr))//头长度
typedef struct _data//数据包中数据结构
{
    char buf[MAX_NUM_BUF];//数据
}DATABUF,*pDataBuf;
//数据包：包头(类型[2byte]+长度[2byte])+数据；

class Client
{
public:
    Client(const SOCKET sClient,const sockaddr_in &addrClient);
    virtual ~Client(void);
public:
    BOOL StartRunning();//创建和接收数据线程
    void HandleData(const char* pExpr);//计算表达式
    BOOL IsConning()//是否连接存在
    {
        return m_bConning;
    }
    void DisConning()//断开与客户端的连接
    {
        m_bConning=FALSE;
    }
    BOOL IsExit()//发送和接收线程是否已经退出
    {
        return m_bExit;
    }
public:
    static DWORD _stdcall RecvDataThread(void* pParam);//接收客户端数据
    static DWORD _stdcall SendDataThread(void* pParam);//向客户端发送数据
public:
    SOCKET  m_socket;//套接字
    sockaddr_in m_addr;//接收客户端的地址
private:
    DATABUF m_data;//客户端数据；接收线程和发送线程公用该数据变量
    HANDLE m_hEvent;//事件对象。当接收线程完成算数表达式的计数后使用该事件对象，通知发送线程发送数据
    HANDLE m_hThreadSend;//发送数据线程句柄
    HANDLE m_hThreadRecv;//接收数据线程句柄
    CRITICAL_SECTION m_cs;//临界区对象。确保接收数据线程和发送数据线程对m_data数据成员的互斥访问
    BOOL m_bConning;//客户端连接状态
    BOOL m_bExit;//线程退出
};

client.cpp

[cpp] view plain copy print ?

#include "StdAfx.h"
#include <process.h>
#include "Client.h"
Client::Client(const SOCKET sClient,const sockaddr_in &addrClient)
{
m_hThreadRecv=NULL;
m_hThreadSend=NULL;
m_socket=sClient;
m_addr=addrClient;
m_bConning=FALSE;
m_bExit=FALSE;
memset(m_data.buf,0,MAX_NUM_BUF);
m_hEvent=CreateEvent(NULL,FALSE,FALSE,NULL);//自动设置信号状态，初始化为无信号状态
InitializeCriticalSection(&m_cs);//初始化临界区
}
Client::~Client(void)
{
closesocket(m_socket);
m_socket=INVALID_SOCKET;
DeleteCriticalSection(&m_cs);//释放临界区
CloseHandle(m_hEvent);//释放事件对象
}
BOOL Client::StartRunning()//创建和接收数据线程
{
m_bConning=TRUE;
if ((m_hThreadRecv=CreateThread(NULL,0,RecvDataThread,this,0,NULL)) == NULL)
{
return FALSE;
}
else
{
CloseHandle(m_hThreadRecv);//成功创建线程后，调用closeHandle()将该线程句柄的引用记数减1
}
if ((m_hThreadSend = CreateThread(NULL,0,SendDataThread,this,0,NULL)) == NULL)
{
return FALSE;
}
else
{
CloseHandle(m_hThreadSend);
}
return TRUE;
}
DWORD Client::RecvDataThread(void* pParam)//接收客户端数据线程
{
Client* pClient=(Client*)pParam;//客户端对象指针
int reVal;//返回值
char temp[MAX_NUM_BUF];//临时变量
memset(temp,0,MAX_NUM_BUF);
for (;pClient->m_bConning;)
{
reVal = recv(pClient->m_socket,temp,MAX_NUM_BUF,0);//接收数据
//处理错误返回值
if (reVal == SOCKET_ERROR)
{
int nErrCode=WSAGetLastError();
if (WSAEWOULDBLOCK == nErrCode)//接受数据缓冲区不可用
{
continue;//继续循环
}
else if( WSAENETDOWN == nErrCode || WSAETIMEDOUT == nErrCode ||WSAECONNRESET == nErrCode)//客户端关闭了连接
{
break;//线程退出
}
}
if( reVal == 0)//客户端关闭了连接
{
break;
}
//接收数据
if (reVal > HEADERLEN)
{
printf("server recv:%s\n",temp);
pClient->HandleData(temp);//处理数据
SetEvent(pClient->m_hEvent);//通知发送数据线程
memset(temp,0,MAX_NUM_BUF);//清空临时变量
}
Sleep(TIMEFOR_THREAD_CLIENT);//线程睡眠
}
pClient->m_bConning=FALSE;//与客户端的连接断开
SetEvent(pClient->m_hEvent);//通知发送线程退出
return 0;//线程退出
}
DWORD Client::SendDataThread(void* pParam)//向客户端发送数据线程
{
Client* pClient=(Client*)pParam;
for (;pClient->m_bConning;)//连接状态
{
//收到事件通知
if (WAIT_OBJECT_0 == WaitForSingleObject(pClient->m_hEvent,INFINITE))//该函数只有当接收到发送数据线程的m_hEvent事件通知时，才会返回。当该函数返回时，说明接收数据线程已经完成了数据的计算。
{
//当客户端的连接断开时，接收数据线程先退出，然后该线程后退出，并设置退出标志
if (!pClient->m_bConning)
{
pClient->m_bExit=TRUE;
break;
}
//进入临界区
EnterCriticalSection(&pClient->m_cs);
//发送数据
phdr pHeander=(phdr)pClient->m_data.buf;
printf("server send client:[%d]%s\n",pHeander->len,pClient->m_data.buf);
int val = send(pClient->m_socket,pClient->m_data.buf,pHeander->len,0);
//处理返回错误
if (SOCKET_ERROR == val)
{
int nErrCode=WSAGetLastError();
if (nErrCode == WSAEWOULDBLOCK)//发送数据缓冲区不可用
{
continue;
}
else if(WSAENETDOWN == nErrCode || WSAETIMEDOUT == nErrCode || WSAECONNRESET == nErrCode)//客户端关闭连接
{
//离开临界区
LeaveCriticalSection(&pClient->m_cs);
pClient->m_bConning=FALSE;//连接断开
pClient->m_bExit=TRUE;//线程退出
break;
}
else
{
//离开临界区
LeaveCriticalSection(&pClient->m_cs);
pClient->m_bConning=FALSE;//连接断开
pClient->m_bExit=TRUE;//线程退出
break;
}
}
//成功发送数据
//离开临界区
LeaveCriticalSection(&pClient->m_cs);
//设置事件为无信号状态
ResetEvent(&pClient->m_hEvent);
}
}
return 0;
}
void Client::HandleData(const char* pExpr)//接收表达式，打包数据
{
memset(m_data.buf,0,MAX_NUM_BUF);
//如果是“byebye”或者“Byebye”
if ('B' == ((phdr)pExpr)->type)
{
EnterCriticalSection(&m_cs);
phdr pHeaderSend=(phdr)m_data.buf;//发送的数据
pHeaderSend->type ='B';//单词类型
pHeaderSend->len=HEADERLEN+strlen("OK");//数据包长度
memcpy(m_data.buf+HEADERLEN,"OK",strlen("OK"));//复制数据到m_data
LeaveCriticalSection(&m_cs);
}
else//算数表达式
{
int nFirNum,nSecNum,nResult;
char cOper;
//格式化读入数据
sscanf(pExpr+HEADERLEN,"%d%c%d",&nFirNum,&cOper,&nSecNum);
//计算
switch (cOper)
{
case '+':
{
nResult=nFirNum+nSecNum;
break;
}
case '-':
{
nResult=nFirNum-nSecNum;
break;
}
case '*':
{
nResult=nFirNum*nSecNum;
break;
}
case '/':
{
if(nSecNum == 0)
nResult=INVALID_NUM;
else
nResult=nFirNum/nSecNum;
break;
}
default:
nResult=INVALID_OPERATOR;
}
//将算数表达式和计算的结果写入字符数组中
char temp[MAX_NUM_BUF];
char cEqu='=';
sprintf(temp,"%d%c%d%c%d",nFirNum,cOper,nSecNum,cEqu,nResult);
//打包数据
EnterCriticalSection(&m_cs);
phdr pHeaderSend=(phdr)m_data.buf;//发送的数据
pHeaderSend->type='E'; //数据类型为算数表达式
pHeaderSend->len=HEADERLEN+strlen(temp);//数据包的长度
memcpy(m_data.buf+HEADERLEN,temp,strlen(temp));//复制数据到m_data
LeaveCriticalSection(&m_cs);
}
}

#include "StdAfx.h"
#include <process.h>
#include "Client.h"

Client::Client(const SOCKET sClient,const sockaddr_in &addrClient)
{
    m_hThreadRecv=NULL;
    m_hThreadSend=NULL;
    m_socket=sClient;
    m_addr=addrClient;
    m_bConning=FALSE;
    m_bExit=FALSE;
    memset(m_data.buf,0,MAX_NUM_BUF);
    m_hEvent=CreateEvent(NULL,FALSE,FALSE,NULL);//自动设置信号状态，初始化为无信号状态
    InitializeCriticalSection(&m_cs);//初始化临界区
}

Client::~Client(void)
{
    closesocket(m_socket);
    m_socket=INVALID_SOCKET;
    DeleteCriticalSection(&m_cs);//释放临界区
    CloseHandle(m_hEvent);//释放事件对象
}
BOOL Client::StartRunning()//创建和接收数据线程
{
    m_bConning=TRUE;
    if ((m_hThreadRecv=CreateThread(NULL,0,RecvDataThread,this,0,NULL)) == NULL)
    {
        return FALSE;
    }
    else
    {
        CloseHandle(m_hThreadRecv);//成功创建线程后，调用closeHandle()将该线程句柄的引用记数减1
    }
    if ((m_hThreadSend = CreateThread(NULL,0,SendDataThread,this,0,NULL)) == NULL)
    {
        return FALSE;
    }
    else
    {
        CloseHandle(m_hThreadSend);
    }
    return TRUE;
}
DWORD Client::RecvDataThread(void* pParam)//接收客户端数据线程
{
    Client* pClient=(Client*)pParam;//客户端对象指针
    int reVal;//返回值
    char temp[MAX_NUM_BUF];//临时变量
    memset(temp,0,MAX_NUM_BUF);
    for (;pClient->m_bConning;)
    {
        reVal = recv(pClient->m_socket,temp,MAX_NUM_BUF,0);//接收数据
        //处理错误返回值
        if (reVal == SOCKET_ERROR)
        {
            int nErrCode=WSAGetLastError();
            if (WSAEWOULDBLOCK == nErrCode)//接受数据缓冲区不可用
            {
                continue;//继续循环
            }
            else if( WSAENETDOWN == nErrCode || WSAETIMEDOUT == nErrCode ||WSAECONNRESET == nErrCode)//客户端关闭了连接
            {
                break;//线程退出
            }
		}

		if( reVal == 0)//客户端关闭了连接
		{
			break;
		}
		//接收数据
		if (reVal > HEADERLEN)
		{
			printf("server recv:%s\n",temp);
			pClient->HandleData(temp);//处理数据
			SetEvent(pClient->m_hEvent);//通知发送数据线程
			memset(temp,0,MAX_NUM_BUF);//清空临时变量
		}
		Sleep(TIMEFOR_THREAD_CLIENT);//线程睡眠
	}
	pClient->m_bConning=FALSE;//与客户端的连接断开
	SetEvent(pClient->m_hEvent);//通知发送线程退出
    return 0;//线程退出
}
DWORD Client::SendDataThread(void* pParam)//向客户端发送数据线程
{
    Client* pClient=(Client*)pParam;
    for (;pClient->m_bConning;)//连接状态
    {
        //收到事件通知
        if (WAIT_OBJECT_0 == WaitForSingleObject(pClient->m_hEvent,INFINITE))//该函数只有当接收到发送数据线程的m_hEvent事件通知时，才会返回。当该函数返回时，说明接收数据线程已经完成了数据的计算。
        {
            //当客户端的连接断开时，接收数据线程先退出，然后该线程后退出，并设置退出标志
            if (!pClient->m_bConning)
            {
                pClient->m_bExit=TRUE;
                break;
            }
            //进入临界区
            EnterCriticalSection(&pClient->m_cs);
            //发送数据
            phdr pHeander=(phdr)pClient->m_data.buf; 
			printf("server send client:[%d]%s\n",pHeander->len,pClient->m_data.buf);
            int val = send(pClient->m_socket,pClient->m_data.buf,pHeander->len,0);
            //处理返回错误
            if (SOCKET_ERROR == val)
            {
                int nErrCode=WSAGetLastError();
                if (nErrCode == WSAEWOULDBLOCK)//发送数据缓冲区不可用
                {
                    continue;
                }
                else if(WSAENETDOWN == nErrCode || WSAETIMEDOUT == nErrCode || WSAECONNRESET == nErrCode)//客户端关闭连接
                {
                    //离开临界区
                    LeaveCriticalSection(&pClient->m_cs);
                    pClient->m_bConning=FALSE;//连接断开
                    pClient->m_bExit=TRUE;//线程退出
                    break;
                }
                else
                {
                    //离开临界区
                    LeaveCriticalSection(&pClient->m_cs);
                    pClient->m_bConning=FALSE;//连接断开
                    pClient->m_bExit=TRUE;//线程退出
                    break;
                }
            }
            //成功发送数据
            //离开临界区
            LeaveCriticalSection(&pClient->m_cs);
            //设置事件为无信号状态
            ResetEvent(&pClient->m_hEvent);
        }
    }
    return 0;
}
void Client::HandleData(const char* pExpr)//接收表达式，打包数据
{
    memset(m_data.buf,0,MAX_NUM_BUF);
    //如果是“byebye”或者“Byebye”
    if ('B' == ((phdr)pExpr)->type)
    {
        EnterCriticalSection(&m_cs);
        phdr pHeaderSend=(phdr)m_data.buf;//发送的数据
        pHeaderSend->type ='B';//单词类型
        pHeaderSend->len=HEADERLEN+strlen("OK");//数据包长度
        memcpy(m_data.buf+HEADERLEN,"OK",strlen("OK"));//复制数据到m_data
        LeaveCriticalSection(&m_cs);
    }
    else//算数表达式
    {
        int nFirNum,nSecNum,nResult;
        char cOper;
        //格式化读入数据
        sscanf(pExpr+HEADERLEN,"%d%c%d",&nFirNum,&cOper,&nSecNum);
        //计算
        switch (cOper)
        {
        case '+':
            {
                nResult=nFirNum+nSecNum;
                break;
            }
        case '-':
            {
                nResult=nFirNum-nSecNum;
                break;
            }
        case '*':
            {
                nResult=nFirNum*nSecNum;
                break;
            }
        case '/':
            {
                if(nSecNum == 0)
                    nResult=INVALID_NUM;
                else
                    nResult=nFirNum/nSecNum;
                break;
            }
        default:
            nResult=INVALID_OPERATOR;
        }
        //将算数表达式和计算的结果写入字符数组中
        char temp[MAX_NUM_BUF];
        char cEqu='=';
        sprintf(temp,"%d%c%d%c%d",nFirNum,cOper,nSecNum,cEqu,nResult);
        //打包数据
        EnterCriticalSection(&m_cs);
        phdr pHeaderSend=(phdr)m_data.buf;//发送的数据
        pHeaderSend->type='E'; //数据类型为算数表达式
        pHeaderSend->len=HEADERLEN+strlen(temp);//数据包的长度
        memcpy(m_data.buf+HEADERLEN,temp,strlen(temp));//复制数据到m_data
        LeaveCriticalSection(&m_cs);
    }
}

NoBlockServer.cpp

[cpp] view plain copy print ?

// NoBlockServer.cpp : 定义控制台应用程序的入口点。
//服务器同时为多个客户端提供服务，实现算术运算和向客户端发送数据的功能
/*
服务器设计以多线程方式工作：
1.建立一个用于接受客户端请求的线程，等待客户端的连接
2.为每一个接受的客户端都建立一个接收数据线程和一个发送数据线程。当接收线程收到数据后，先计算算数表达式的结果，然后使用事件通知发送数据线程。发送数据线程接收到事件后，将计算结果发送给客户端
3.建立一个资源清理线程，用于及时对服务器的资源进行清理。当客户端的套接字关闭之后，需要清理为该客户端创建的线程和分配的内存空间
4.服务器的主线程用于接收用户的输入和显示信息
5.服务器仅显示启动和退出的界面。在子线程中完成对客户端数据的处理，不在服务器界面上显示客户端的数据。
6.所有子线程都必须自动退出，不调用线程结束函数。在所有子线程都退出后，主线程最后退出
*/
#include "stdafx.h"
#include <WinSock2.h>
#include <iostream>
#include <list>
#include "Client.h"
using namespace std;
#pragma comment(lib,"ws2_32.lib")
#define TIMEFOR_THREAD_EXIT 5000 //主线程睡眠时间
#define TIMEFOR_THREAD_HELP 1500 //清理资源线程退出时间
#define TIMEFOR_THREAD_SLEEP 500 //等待客户端请求线程睡眠时间
typedef list<Client*> CLIENTLIST;//链表；管理客户端连接的链表。把每个连接的客户端作为链表的一个节点。使用该链表对客户端的接入和退出进行管理。
CLIENTLIST clientList;//管理连接的链表
HANDLE hThreadAccept;//接受客户端连接线程句柄
HANDLE hThreadHelp;//释放资源线程句柄
SOCKET sServer;//监听套接字
BOOL bServerRunning;//服务器的工作状态
HANDLE hServerEvent;//关闭服务器事件对象
CRITICAL_SECTION csClientList;//保护链表的临界区对象
BOOL InitServer();//初始化
BOOL StartService();//启动服务
void StopService();//停止服务
BOOL CreateHelperAndAcceptThread();//创建客户端连接线程
void ExitServer();//服务器退出
void InitMember();//初始化全局变量
BOOL InitSocket();//初始化SOCKET
DWORD _stdcall HelperThread(void *pParam);//释放资源
DWORD _stdcall AcceptThread(void *pParam);//接受客户端连接线程
void main()
{
if (!InitServer())
{
ExitServer();
return;
}
if (!StartService())
{
ExitServer();
return;
}
StopService();
ExitServer();
system("pause");
return;
}
BOOL InitServer()//初始化
{
InitMember();
if (!InitSocket())
{
return FALSE;
}
return TRUE;
}
void InitMember()//初始化全局变量
{
InitializeCriticalSection(&csClientList);//初始化临界区
//为了便于控制服务器退出事件对象的状态，将该事件对象设置为手动模式。
hServerEvent = CreateEvent(NULL,TRUE,FALSE,NULL);//手动设置事件，初始化为无信号状态
hThreadAccept=NULL;
hThreadHelp=NULL;
sServer=INVALID_SOCKET;
bServerRunning=FALSE;
clientList.clear();//清空链表
}
BOOL InitSocket()//初始化SOCKET
{
WSAData wsData;
if (WSAStartup(MAKEWORD(2,2),&wsData) != 0)
{
return FALSE;
}
if ((sServer = socket(AF_INET,SOCK_STREAM,0)) == INVALID_SOCKET)
{
return FALSE;
}
//设置套接字为非阻塞模式
unsigned long ul=1;
if (ioctlsocket(sServer,FIONBIO,&ul) == SOCKET_ERROR)
{
return FALSE;
}
SOCKADDR_IN addrServ;
addrServ.sin_family=AF_INET;
addrServ.sin_addr.s_addr=INADDR_ANY;
addrServ.sin_port=htons(5000);
if (bind(sServer,(SOCKADDR*)&addrServ,sizeof(addrServ)) == SOCKET_ERROR)
{
return FALSE;
}
if (listen(sServer,SOMAXCONN) == SOCKET_ERROR)
{
return FALSE;
}
printf("start listen...\n");
return TRUE;
}
BOOL StartService()//启动服务
{
return CreateHelperAndAcceptThread();//创建清理资源和接收客户端连接请求的线程
}
/* 服务器退出
当关闭服务器时，服务器向清理资源线程和接收客户端请求连接线程发送退出信号。接收客户端线程将自动退出。
清理资源线程向所有正在于客户端进行通讯的接收和发送数据线程，发送服务器退出消息，使这些线程自动退出。当这些线程退出后，清理资源线程再向主线程发送消息，然后改线程退出。主线程在接收到清理资源线程发送的消息后，最后退出。
*/
void StopService()//停止服务，等待用户输入退出服务器命令。当用户确定退出服务器时，有清理资源线程停止客户端的服务，所有子线程退出。
{
printf("tip--->e(E):Exit server. please input:\n");
char cInput;
for (;bServerRunning;)
{
cin >> cInput;
if (cInput == 'E' || cInput == 'e')
{
if (IDOK == MessageBox(NULL,L"Are you sure?",L"Server",MB_OKCANCEL)) //等待用户确认退出的消息框
{
break;//跳出循环体
}
else
{
Sleep(TIMEFOR_THREAD_EXIT);//线程睡眠
}
}
else
{
Sleep(TIMEFOR_THREAD_EXIT);//线程睡眠
}
}
bServerRunning=FALSE;
cout<<"Server exit ..."<<endl;//显示服务器退出信息
Sleep(TIMEFOR_THREAD_EXIT);//给其他线程时间退出
WaitForSingleObject(hServerEvent,INFINITE);//等待清理资源线程发送事件；该函数直到收到清理资源线程发送的服务器退出事件后才返回
}
BOOL CreateHelperAndAcceptThread()//创建客户端连接线程
{
bServerRunning=TRUE;
//创建释放资源线程
if ((hThreadHelp=CreateThread(NULL,0,HelperThread,NULL,0,NULL)) == NULL)//第5个参数:0表示新创建的线程将立即运行各种的线程函数
{
bServerRunning =FALSE;
cout<<"Server failed!"<<endl;
return FALSE;
}
else
{
CloseHandle(hThreadHelp);
}
//创建接收客户端请求线程
if ((hThreadAccept=CreateThread(NULL,0,AcceptThread,NULL,0,NULL)) == NULL)
{
bServerRunning =FALSE;
cout<<"Server failed!"<<endl;
return FALSE;
}
else
{
CloseHandle(hThreadAccept);
}
cout<<"Server succeded!"<<endl;
return TRUE;
}
void ExitServer()//服务器退出
{
DeleteCriticalSection(&csClientList);//释放临界区对象
CloseHandle(hServerEvent);//释放事件对象句柄
closesocket(sServer);//关闭SOCKET
WSACleanup();//卸载WindowsSocketDLL
}
DWORD _stdcall HelperThread(void *pParam)//释放资源
{
/* 客户端退出
当接收数据线程获知客户端请求结束时，向发送数据线程的线程发送消息使其退出，然后，该线程退出线程。同时清理资源线程清理该线程的占用资源。
*/
for (;bServerRunning;)//服务器正在运行
{
EnterCriticalSection(&csClientList);//进入临界区
//清理已经断开的连接客户端内存空间
CLIENTLIST::iterator iter=clientList.begin();
for (;iter != clientList.end();)
{
Client* pClient=(Client*)*iter;
if (pClient->IsExit())//客户端线程已经退出
{
printf("first server delete a client[%s],id=%d\n",inet_ntoa(pClient->m_addr.sin_addr),pClient->m_socket);
clientList.erase(iter++);//删除节点
delete pClient;//释放内存
pClient=NULL;
}
else
{
iter++;
}
}
LeaveCriticalSection(&csClientList);//离开临界区
Sleep(TIMEFOR_THREAD_HELP);
}
//服务器停止工作
if (!bServerRunning)
{
//断开每个连接，线程退出
EnterCriticalSection(&csClientList);
CLIENTLIST::iterator iter=clientList.begin();
for (;iter != clientList.end();)
{
Client* pClient=(Client*)*iter;
//如果客户端的连接还存在，则断开连接，线程退出
if (pClient->IsConning())
{
pClient->DisConning();
}
++iter;
}
LeaveCriticalSection(&csClientList);//离开临界区
Sleep(TIMEFOR_THREAD_SLEEP);//给连接客户端线程时间，使其自动退出
EnterCriticalSection(&csClientList);//进入临界区
//确保为每个客户端分配的内存空间都回收。如果不加入while()这层循环，可能存在这样的情况，当pClient->IsExit()时，该线程还没有退出。那么就需要从链表的开始部分重新判断
while(clientList.size() != 0)
{
iter = clientList.begin();
for (;iter != clientList.end();iter++)
{
Client* pClient=(Client*)*iter;
if (pClient->IsExit())//客户端线程已经退出
{
printf("second server delete a client[%s],id=%d\n",inet_ntoa(pClient->m_addr.sin_addr),pClient->m_socket);
clientList.erase(iter++);//删除节点
delete pClient;//释放内存空间
pClient=NULL;
}
}
Sleep(TIMEFOR_THREAD_SLEEP);//给连接客户端线程时间，使其自动退出
}
LeaveCriticalSection(&csClientList);//离开临界区
}
clientList.clear();//清空线程
SetEvent(hServerEvent);//通知主线程退出
return 0;
}
DWORD _stdcall AcceptThread(void *pParam)//接受客户端连接线程
{
SOCKET sAccept;
sockaddr_in addrClient;
while(bServerRunning)
{
memset(&addrClient,0,sizeof(sockaddr_in));
int lenClient=sizeof(sockaddr_in);
sAccept=accept(sServer,(sockaddr*)&addrClient,&lenClient);
if (INVALID_SOCKET == sAccept)
{
int nErrCode=WSAGetLastError();
if (nErrCode == WSAEWOULDBLOCK)//无法立即完成一个非阻挡性套接字操作
{
Sleep(TIMEFOR_THREAD_SLEEP);
continue;//继续等待
}
else
{
return 0;//线程退出
}
}
else//接受客户端的请求
{
Client* pClient=new Client(sAccept,addrClient);//创建客户端对象
printf("server accept a client[%s]:%d;id=%d\n",inet_ntoa(addrClient.sin_addr),ntohs(addrClient.sin_port),sAccept);
EnterCriticalSection(&csClientList);//进入临界区
clientList.push_back(pClient);//加入链表
LeaveCriticalSection(&csClientList);//离开临界区
pClient->StartRunning();//为接受的客户端建立接受数据和发送数据线程
}
}
return 0;//线程退出
}

// NoBlockServer.cpp : 定义控制台应用程序的入口点。
//服务器同时为多个客户端提供服务，实现算术运算和向客户端发送数据的功能
/*
服务器设计以多线程方式工作：
1.建立一个用于接受客户端请求的线程，等待客户端的连接
2.为每一个接受的客户端都建立一个接收数据线程和一个发送数据线程。当接收线程收到数据后，先计算算数表达式的结果，然后使用事件通知发送数据线程。发送数据线程接收到事件后，将计算结果发送给客户端
3.建立一个资源清理线程，用于及时对服务器的资源进行清理。当客户端的套接字关闭之后，需要清理为该客户端创建的线程和分配的内存空间
4.服务器的主线程用于接收用户的输入和显示信息
5.服务器仅显示启动和退出的界面。在子线程中完成对客户端数据的处理，不在服务器界面上显示客户端的数据。
6.所有子线程都必须自动退出，不调用线程结束函数。在所有子线程都退出后，主线程最后退出
*/
#include "stdafx.h"
#include <WinSock2.h>
#include <iostream>
#include <list>
#include "Client.h"
using namespace std;
#pragma comment(lib,"ws2_32.lib")
#define  TIMEFOR_THREAD_EXIT 5000 //主线程睡眠时间
#define  TIMEFOR_THREAD_HELP 1500  //清理资源线程退出时间
#define  TIMEFOR_THREAD_SLEEP 500 //等待客户端请求线程睡眠时间
typedef list<Client*> CLIENTLIST;//链表；管理客户端连接的链表。把每个连接的客户端作为链表的一个节点。使用该链表对客户端的接入和退出进行管理。
CLIENTLIST clientList;//管理连接的链表
HANDLE hThreadAccept;//接受客户端连接线程句柄
HANDLE hThreadHelp;//释放资源线程句柄
SOCKET sServer;//监听套接字
BOOL bServerRunning;//服务器的工作状态
HANDLE hServerEvent;//关闭服务器事件对象
CRITICAL_SECTION csClientList;//保护链表的临界区对象


BOOL InitServer();//初始化
BOOL StartService();//启动服务
void StopService();//停止服务
BOOL CreateHelperAndAcceptThread();//创建客户端连接线程
void ExitServer();//服务器退出

void InitMember();//初始化全局变量
BOOL InitSocket();//初始化SOCKET 

DWORD _stdcall HelperThread(void *pParam);//释放资源
DWORD _stdcall AcceptThread(void *pParam);//接受客户端连接线程 

void main()
{
    if (!InitServer())
    {
        ExitServer();
        return;
    }
    if (!StartService())
    { 
        ExitServer();
        return;
    }
    StopService();
    ExitServer();
    system("pause");
    return;
}

BOOL InitServer()//初始化
{
    InitMember();
    if (!InitSocket())
    {
        return FALSE;
    }
    return TRUE;
}
void InitMember()//初始化全局变量
{
    InitializeCriticalSection(&csClientList);//初始化临界区
	//为了便于控制服务器退出事件对象的状态，将该事件对象设置为手动模式。
    hServerEvent = CreateEvent(NULL,TRUE,FALSE,NULL);//手动设置事件，初始化为无信号状态
    hThreadAccept=NULL;
    hThreadHelp=NULL;
    sServer=INVALID_SOCKET;
    bServerRunning=FALSE;
	clientList.clear();//清空链表
}
BOOL InitSocket()//初始化SOCKET
{
    WSAData wsData;
    if (WSAStartup(MAKEWORD(2,2),&wsData) != 0)
    {
        return FALSE;
    }
    if ((sServer = socket(AF_INET,SOCK_STREAM,0)) == INVALID_SOCKET)
    {
        return FALSE;
    }
    //设置套接字为非阻塞模式
    unsigned long ul=1;
    if (ioctlsocket(sServer,FIONBIO,&ul) == SOCKET_ERROR)
    {
        return FALSE;
    }

    SOCKADDR_IN addrServ;
    addrServ.sin_family=AF_INET;
    addrServ.sin_addr.s_addr=INADDR_ANY;
    addrServ.sin_port=htons(5000);
    if (bind(sServer,(SOCKADDR*)&addrServ,sizeof(addrServ)) == SOCKET_ERROR)
    {
        return FALSE;
    }
    if (listen(sServer,SOMAXCONN) == SOCKET_ERROR)
    {
        return FALSE;
    }
	printf("start listen...\n");
    return TRUE;
}
BOOL StartService()//启动服务
{
	return CreateHelperAndAcceptThread();//创建清理资源和接收客户端连接请求的线程 
}
/* 服务器退出
当关闭服务器时，服务器向清理资源线程和接收客户端请求连接线程发送退出信号。接收客户端线程将自动退出。
清理资源线程向所有正在于客户端进行通讯的接收和发送数据线程，发送服务器退出消息，使这些线程自动退出。当这些线程退出后，清理资源线程再向主线程发送消息，然后改线程退出。主线程在接收到清理资源线程发送的消息后，最后退出。
*/
void StopService()//停止服务，等待用户输入退出服务器命令。当用户确定退出服务器时，有清理资源线程停止客户端的服务，所有子线程退出。
{ 
	printf("tip--->e(E):Exit server. please input:\n"); 
    char cInput;
    for (;bServerRunning;)
    {
        cin >> cInput;
        if (cInput == 'E' || cInput == 'e')
        {
            if (IDOK == MessageBox(NULL,L"Are you sure?",L"Server",MB_OKCANCEL)) //等待用户确认退出的消息框
            {
                break;//跳出循环体
            }
            else
            {
                Sleep(TIMEFOR_THREAD_EXIT);//线程睡眠
            }
        }
        else
        {
            Sleep(TIMEFOR_THREAD_EXIT);//线程睡眠
        }
    }
    bServerRunning=FALSE;
	cout<<"Server exit ..."<<endl;//显示服务器退出信息
    Sleep(TIMEFOR_THREAD_EXIT);//给其他线程时间退出
    WaitForSingleObject(hServerEvent,INFINITE);//等待清理资源线程发送事件；该函数直到收到清理资源线程发送的服务器退出事件后才返回
}
BOOL CreateHelperAndAcceptThread()//创建客户端连接线程
{
    bServerRunning=TRUE;
    //创建释放资源线程
    if ((hThreadHelp=CreateThread(NULL,0,HelperThread,NULL,0,NULL)) == NULL)//第5个参数:0表示新创建的线程将立即运行各种的线程函数
    {
		bServerRunning =FALSE;
		cout<<"Server failed!"<<endl;
        return FALSE;
    }
    else
    {
        CloseHandle(hThreadHelp);
    }
    //创建接收客户端请求线程
    if ((hThreadAccept=CreateThread(NULL,0,AcceptThread,NULL,0,NULL)) == NULL)
    {
		bServerRunning =FALSE;
		cout<<"Server failed!"<<endl;
        return FALSE;
    }
    else
    {
        CloseHandle(hThreadAccept);
    }
	cout<<"Server succeded!"<<endl;
    return TRUE;
}
void ExitServer()//服务器退出
{
	DeleteCriticalSection(&csClientList);//释放临界区对象
    CloseHandle(hServerEvent);//释放事件对象句柄
    closesocket(sServer);//关闭SOCKET
    WSACleanup();//卸载WindowsSocketDLL
}

DWORD _stdcall HelperThread(void *pParam)//释放资源
{
	/* 客户端退出
	当接收数据线程获知客户端请求结束时，向发送数据线程的线程发送消息使其退出，然后，该线程退出线程。同时清理资源线程清理该线程的占用资源。
	*/
   for (;bServerRunning;)//服务器正在运行
   {
	   EnterCriticalSection(&csClientList);//进入临界区

	   //清理已经断开的连接客户端内存空间
	   CLIENTLIST::iterator iter=clientList.begin();
	   for (;iter != clientList.end();)
	   {
		   Client* pClient=(Client*)*iter;
		   if (pClient->IsExit())//客户端线程已经退出
		   {
			   printf("first server delete a client[%s],id=%d\n",inet_ntoa(pClient->m_addr.sin_addr),pClient->m_socket);
			   clientList.erase(iter++);//删除节点
			   delete pClient;//释放内存
			   pClient=NULL;
		   }
		   else
		   {
			   iter++;		   
		   }
	   }
	   LeaveCriticalSection(&csClientList);//离开临界区
	   Sleep(TIMEFOR_THREAD_HELP);
   }

   //服务器停止工作
   if (!bServerRunning)
   {
	   //断开每个连接，线程退出
	   EnterCriticalSection(&csClientList);
	   CLIENTLIST::iterator iter=clientList.begin();
	   for (;iter != clientList.end();)
	   {
		   Client* pClient=(Client*)*iter;
		   //如果客户端的连接还存在，则断开连接，线程退出
		   if (pClient->IsConning())
		   {
			   pClient->DisConning();
		   }
		   ++iter;
	   }
	   LeaveCriticalSection(&csClientList);//离开临界区
	   Sleep(TIMEFOR_THREAD_SLEEP);//给连接客户端线程时间，使其自动退出

	   EnterCriticalSection(&csClientList);//进入临界区
	   //确保为每个客户端分配的内存空间都回收。如果不加入while()这层循环，可能存在这样的情况，当pClient->IsExit()时，该线程还没有退出。那么就需要从链表的开始部分重新判断
	   while(clientList.size() != 0)
	   {
		   iter = clientList.begin();
		   for (;iter != clientList.end();iter++)
		   {
			   Client* pClient=(Client*)*iter;
			   if (pClient->IsExit())//客户端线程已经退出
			   {
				   printf("second server delete a client[%s],id=%d\n",inet_ntoa(pClient->m_addr.sin_addr),pClient->m_socket);
				   clientList.erase(iter++);//删除节点
				   delete pClient;//释放内存空间
				   pClient=NULL;
			   }
		   }
		   Sleep(TIMEFOR_THREAD_SLEEP);//给连接客户端线程时间，使其自动退出
	   }
	   LeaveCriticalSection(&csClientList);//离开临界区
   }
   clientList.clear();//清空线程
   SetEvent(hServerEvent);//通知主线程退出
   return 0;
}

DWORD _stdcall AcceptThread(void *pParam)//接受客户端连接线程
{
	SOCKET sAccept;
	sockaddr_in addrClient;
	while(bServerRunning)
	{
		memset(&addrClient,0,sizeof(sockaddr_in));
		int lenClient=sizeof(sockaddr_in);
		sAccept=accept(sServer,(sockaddr*)&addrClient,&lenClient);
		if (INVALID_SOCKET == sAccept)
		{
			int nErrCode=WSAGetLastError();
			if (nErrCode == WSAEWOULDBLOCK)//无法立即完成一个非阻挡性套接字操作
			{
				Sleep(TIMEFOR_THREAD_SLEEP);
				continue;//继续等待
			}
			else
			{
				return 0;//线程退出
			}
		}
		else//接受客户端的请求
		{
			Client* pClient=new Client(sAccept,addrClient);//创建客户端对象
			printf("server accept a client[%s]:%d;id=%d\n",inet_ntoa(addrClient.sin_addr),ntohs(addrClient.sin_port),sAccept);
			EnterCriticalSection(&csClientList);//进入临界区
			clientList.push_back(pClient);//加入链表
			LeaveCriticalSection(&csClientList);//离开临界区
			pClient->StartRunning();//为接受的客户端建立接受数据和发送数据线程
		}
	}
    return 0;//线程退出
}

NoBlockClient

NoBlockClient.cpp

[cpp] view plain copy print ?

// NoBlockClient.cpp : 定义控制台应用程序的入口点。
/*
客户端为多线程工作方式，主线程显示用户的输入和数据的计算结果，子线程接收和发送数据
1.主线程用于所有的界面显示和接收用户的输入
2.建立一个数据发送线程，当数据打包后，通知该线程向服务器发送数据
3.建立一个数据接收线程。当该线程接收到服务器发送的数据后，由该线程完成对数据的解包，并通知主线程显示结果
4.所有的子线程都必须自动退出。在所有字线程都退出后，主线程最后退出
客户端退出：
客户端首先向服务器发送"byebye"或"Byebye"消息，然后等待服务器的返回消息。当客户端的接收数据线程收到服务器返回的"OK"消息后，通知主线程显示该消息。然后，主线程通知发送数据线程和接收数据线程退出。在确定这两个线程都退出后，主线程最后退出。
*/
#include <winsock2.h>
#include <stdio.h>
#include <iostream>
using namespace std;
#pragma comment(lib,"ws2_32.lib")
#define TIMEFOR_THREAD_EXIT 1000
#define TIMEFOR_THREAD_SLEEP 500
#define BUF_MAX_NUM 64
#define HEADERLEN (sizeof(hdr))
typedef struct _head//数据包包头结构该结构在win32xp下为4byte
{
char type;//类型
unsigned short len;//数据包的长度(包括头的长度)
}hdr,*phdr;
typedef struct _data//数据包中的数据结构
{
char buf[BUF_MAX_NUM];
}DATABUF,*pDataBuf;
//数据包：包头(类型[2byte]+长度[2byte])+数据；
SOCKET sClient;//套接字
HANDLE hThreadSend;//发送数据线程
HANDLE hThreadRecv;//接收数据线程
DATABUF bufSend;//发送数据缓冲区
DATABUF bufRecv;//接收数据缓冲区
CRITICAL_SECTION csSend;//当读写 bufSend变量时，要在之前进入临界区，之后退出临界区;//临界区对象，锁定bufSend
CRITICAL_SECTION csRecv;//当读写 bufRecv变量时，要在之前进入临界区，之后退出临界区;//临界区对象，锁定bufRecv
BOOL bSendData;//通知发送数据线程发送数据
HANDLE hEventShowDataResult;//显示计算结果的事件
BOOL bConnected;//与服务器的连接状态
HANDLE arrThread[2];//子线程数组
BOOL InitClient();//初始化
BOOL ConnectServer();//连接服务器
BOOL CreateSendAndRecvThread();//创建发送和接收数据线程
void InputAndOutput();//用户输入数据和显示结果
void ExitClient();//退出
void InitMember();//初始化全局变量
BOOL InitSocket();//创建SOCKET
DWORD _stdcall RecvDataThread(LPVOID pParam);//接收数据线程
DWORD _stdcall SendDataThread(LPVOID pParam);//发送数据线程
BOOL PackByebye(const char* pExpr);//将输入的"Byebye","byebye"字符串打包
BOOL PackExpression(const char* pExpr);//将输入的算数表达式打包
void ShowConnectMsg(BOOL bConnected);//显示连接服务器消息
void ShowDataResultMsg();//显示计算结果
void ShowTipMsg(BOOL bFirstInput);//显示提示信息
int main()
{
if (!InitClient())
{
ExitClient();
return 0;
}
if (ConnectServer())
{
ShowConnectMsg(TRUE);
}
else
{
ShowConnectMsg(FALSE);
ExitClient();
return 0;
}
if (!CreateSendAndRecvThread()) //创建发送和接收数据线程
{
ExitClient();
return 0;
}
InputAndOutput();//用户输入数据和显示结果
ExitClient();//退出
system("pause");
return 0;
}
BOOL InitClient()//初始化
{
InitMember();
if (!InitSocket())
{
return FALSE;
}
return TRUE;
}
void InitMember()//初始化全局变量
{
InitializeCriticalSection(&csSend);
InitializeCriticalSection(&csRecv);
sClient=INVALID_SOCKET;
hThreadRecv=NULL;
hThreadSend=NULL;
bConnected=FALSE;
bSendData=FALSE;
memset(bufRecv.buf,0,BUF_MAX_NUM);
memset(bufSend.buf,0,BUF_MAX_NUM);
//手动设置事件，初始化为无信号状态
hEventShowDataResult=(HANDLE)CreateEvent(NULL,TRUE,FALSE,NULL);
}
BOOL InitSocket()//创建SOCKET
{
WSADATA wsd;
if (WSAStartup(MAKEWORD(2,2),&wsd) != 0)
{
return FALSE;
}
if ((sClient=socket(AF_INET,SOCK_STREAM,0)) == INVALID_SOCKET)
{
return FALSE;
}
//设置套接字为非阻塞模式
unsigned long ul=1;
if (ioctlsocket(sClient,FIONBIO,&ul) == SOCKET_ERROR)
{
return FALSE;
}
return TRUE;
}
BOOL ConnectServer()//连接服务器
{
SOCKADDR_IN addrServ;
addrServ.sin_family=AF_INET;
addrServ.sin_addr.s_addr=inet_addr("127.0.0.1");
addrServ.sin_port=htons(5000);
int reVal;
while (1)
{
reVal=connect(sClient,(SOCKADDR*)&addrServ,sizeof(addrServ));
//处理连接错误。当使用非阻塞套接字时，建议最好不要使用这种方法来判断客户端是否成功连接服务器。推荐使用select(),WSAAsyncSelect()或者WSAEventselect()，来判断连接服务器是否成功。在后面的章节中会讲解到。
if (reVal == SOCKET_ERROR)
{
int nErrCode=WSAGetLastError();
if (nErrCode == WSAEWOULDBLOCK || nErrCode == WSAEINVAL)//连接未能够立即完成；监听状态
{
continue;
}
else if (nErrCode == WSAEISCONN)//连接已经完成
{
break;
}
else//其他原因，连接失败
{
return FALSE;
}
}
if(reVal == 0)//连接成功
{
break;
}
}
bConnected=TRUE;
return TRUE;
}
BOOL CreateSendAndRecvThread()//创建发送和接收数据线程
{
unsigned long ulThreadId;
if ((hThreadRecv=CreateThread(NULL,0,RecvDataThread,NULL,0,&ulThreadId)) == NULL)
{
return FALSE;
}
if ((hThreadSend=CreateThread(NULL,0,SendDataThread,NULL,0,&ulThreadId)) == NULL)
{
return FALSE;
}
arrThread[0]=hThreadRecv;
arrThread[1]=hThreadSend;
return TRUE;
}
/* 客户端退出
客户端首先向服务器发送"Byebye","byebye"消息，然后等待服务器的返回消息。当客户端的接收数据线程收到服务器返回的"OK"消息后，通知主线程显示该消息。然后，主线程通知发送数据线程和接收数据线程退出。在确认这两个线程都退出后，主线程最后退出。
*/
void InputAndOutput()//用户输入数据和显示结果
{
char cInput[BUF_MAX_NUM];//用户输入缓冲区
BOOL bFirstInput=TRUE;//第一次只能输入算术表达式
while(bConnected)//连接状态
{
memset(cInput,0,BUF_MAX_NUM);
ShowTipMsg(bFirstInput);//提示输入信息
cin >> cInput;
char* pTemp=cInput;
if (bFirstInput)//第一次输入
{
if (!PackExpression(pTemp))//算数表达式打包
{
continue;//重新输入
}
bFirstInput = FALSE;//成功输入第一个算数表达式
}
else if (!PackByebye(pTemp))//Byebye byebye 打包
{
if (!PackExpression(pTemp))//算数表达式打包
{
continue;//重新输入
}
}
//等待显示结果
if (WAIT_OBJECT_0 == WaitForSingleObject(hEventShowDataResult,INFINITE))
{
ResetEvent(hEventShowDataResult);//设置为无信号状态
if (!bConnected)//客户端被动退出，此时接收和发送数据线程已经退出。
{
break;
}
ShowDataResultMsg();//显示数据
if (0 == strcmp(bufRecv.buf,"OK"))//客户端主动退出
{
bConnected=FALSE;
Sleep(TIMEFOR_THREAD_EXIT);//给数据接收和发送线程退出时间
}
}
}
if (!bConnected)//与服务器连接已经断开
{
ShowConnectMsg(FALSE);//显示信息
}
//等待数据发送和接收线程退出;为了做到主线程最后退出
if (WAIT_ABANDONED_0 == WaitForMultipleObjects(2,arrThread,TRUE,INFINITE))
{
int nErrCode=GetLastError();
}
}
void ExitClient()//退出
{
DeleteCriticalSection(&csSend);
DeleteCriticalSection(&csRecv);
CloseHandle(hThreadRecv);
CloseHandle(hThreadSend);
closesocket(sClient);
WSACleanup();
}
DWORD _stdcall RecvDataThread(LPVOID pParam)//接收数据线程
{
int reVal;
char temp[BUF_MAX_NUM];
memset(temp,0,BUF_MAX_NUM);
while(bConnected)//连接状态
{
reVal = recv( sClient,temp,BUF_MAX_NUM,0);//接收数据
if ( SOCKET_ERROR == reVal)//接受数据缓冲区不可用
{
int nErrCode = WSAGetLastError();
if (WSAEWOULDBLOCK == nErrCode)
{
Sleep(TIMEFOR_THREAD_SLEEP);//线程睡眠
continue;//继续接收数据
}
else
{
bConnected = FALSE;
SetEvent(hEventShowDataResult);//通知主线程，防止在无限期的等待
return 0;//线程退出
}
}
if ( 0 == reVal)//服务器关闭了连接
{
bConnected = FALSE;//线程退出
SetEvent(hEventShowDataResult);//通知主线程，防止在无限期的等待
return 0;//线程退出
}
if ( reVal > HEADERLEN && reVal != -1)//收到数据
{
//对数据解包
phdr header =(phdr)temp;
EnterCriticalSection(&csRecv);
memset(bufRecv.buf,0,BUF_MAX_NUM);
memcpy(bufRecv.buf,temp + HEADERLEN,header->len - HEADERLEN);//将数据结果复制到接收数据缓冲区
LeaveCriticalSection(&csRecv);
SetEvent(hEventShowDataResult);//通知主线程显示计算结果
memset(temp,0,BUF_MAX_NUM);
}
Sleep(TIMEFOR_THREAD_SLEEP);//线程睡眠
}
return 0;
}
DWORD _stdcall SendDataThread(LPVOID pParam)//发送数据线程
{
while(bConnected)//连接状态
{
if (bSendData)//发送数据
{
EnterCriticalSection(&csSend);//进入临界区
while(TRUE)
{
int nBuflen=((phdr)bufSend.buf)->len;
int val = send(sClient,bufSend.buf,nBuflen,0);
//处理返回错误
if (SOCKET_ERROR == val)
{
int nErrCode = WSAGetLastError();
if (WSAEWOULDBLOCK == nErrCode)//发送缓冲区不可用
{
continue;//继续循环
}
else
{
LeaveCriticalSection(&csSend);//离开临界区
bConnected = FALSE;//断开状态
SetEvent(hEventShowDataResult);//通知主线程，防止在无限期的等待返回结果。
return 0;
}
}
bSendData = FALSE;//发送状态
break;//跳出for
}
LeaveCriticalSection(&csSend);//离开临界区
}
Sleep(TIMEFOR_THREAD_SLEEP);//线程睡眠
}
return 0;
}
BOOL PackByebye(const char* pExpr)//将输入的"Byebye","byebye"字符串打包
{
BOOL reVal = FALSE;
if (!strcmp("Byebye",pExpr) || !strcmp("byebye",pExpr))
{
EnterCriticalSection(&csSend);
phdr pHeader =(phdr)bufSend.buf;//强制转换
pHeader->type='B';//类型
pHeader->len = HEADERLEN + strlen("Byebye");//数据包长度
memcpy(bufSend.buf + HEADERLEN,pExpr,strlen(pExpr));//复制数据
LeaveCriticalSection(&csSend);
pHeader = NULL;
bSendData = TRUE;//通知发送数据线程
reVal = TRUE;
}
return reVal;
}
BOOL PackExpression(const char* pExpr)//将输入的算数表达式打包
{
char* pTemp = (char*)pExpr;//算数表达式数字开始的位置
while (!*pTemp)//第一个数字位置
{
pTemp++;
}
char* pos1=pTemp;
char* pos2=NULL;
char* pos3=NULL;
int len1=0,len2=0,len3=0;
if ((*pTemp != '+') && (*pTemp != '-') && ((*pTemp < '0') || (*pTemp > '9')))//第一个字符是+ - 或者是数字
{
return FALSE;
}
if ((*pTemp++ == '-')&&(*pTemp < '0' || *pTemp > '9')) //第一个字符是'-',第二个是数字
return FALSE; //重新输入
--pTemp; //上移指针
char* pNum = pTemp; //数字开始的位置
if (*pTemp == '+'||*pTemp == '-') //+ -
pTemp++;
while (*pTemp >= '0' && *pTemp <= '9') //数字
pTemp++;
len1 = pTemp - pNum;//数字长度
//可能有空格
while(!*pTemp)
pTemp++;
//算数运算符
if (('+' != *pTemp) && ('-' != *pTemp) && ('*' != *pTemp) && ('/' != *pTemp))
return FALSE;
pos2 = pTemp;
len2 = 1;
//下移指针
pTemp++;
//可能有空格
while(!*pTemp)
pTemp++;
//第2个数字位置
pos3 = pTemp;
if (*pTemp < '0' || *pTemp > '9')
return FALSE;//重新输入
while (*pTemp >= '0' && *pTemp <= '9')//数字
pTemp++;
if ('=' != *pTemp) //最后是等于号
return FALSE; //重新输入
len3 = pTemp - pos3;//数字长度
int nExprlen = len1 + len2 + len3; //算数表示长度
//表达式读入发送数据缓冲区
EnterCriticalSection(&csSend); //进入临界区
//数据包头
phdr pHeader = (phdr)(bufSend.buf);
pHeader->type = 'E'; //类型
pHeader->len = nExprlen + HEADERLEN;//数据包长度
//拷贝数据
memcpy(bufSend.buf + HEADERLEN, pos1, len1);
memcpy(bufSend.buf + HEADERLEN + len1, pos2, len2);
memcpy(bufSend.buf + HEADERLEN + len1 + len2 , pos3,len3);
LeaveCriticalSection(&csSend); //离开临界区
pHeader = NULL;
bSendData = TRUE; //通知发送数据线程发送数据
return TRUE;
}
void ShowConnectMsg(BOOL bSuc)//显示连接服务器失败消息
{
if (bSuc)
{
cout << "* Succeed to connect server! *" << endl;
}
else
{
cout << "* Fail to connect server! *" << endl;
}
}
void ShowDataResultMsg()//显示计算结果
{
EnterCriticalSection(&csRecv);
cout << "***Result: "<<bufRecv.buf <<endl;
LeaveCriticalSection(&csRecv);
}
void ShowTipMsg(BOOL bFirstInput)//显示提示信息
{
if (bFirstInput)//首次显示
{
cout << "**********************************" << endl;
cout << "* *" << endl;
cout << "* Please input expression. *" << endl;
cout << "* Usage:NumberOperatorNumber= *" << endl;
cout << "* *" << endl;
cout << "**********************************" << endl;
}else{
cout << "**********************************" << endl;
cout << "* *" << endl;
cout << "* Please input: expression *" << endl;
cout << "* Usage:NumberOperatorNumber= *" << endl;
cout << "* *" << endl;
cout << "* If you want to exit. *" << endl;
cout << "* Usage: Byebye or byebye *" << endl;
cout << "* *" << endl;
cout << "**********************************" << endl;
}
}

// NoBlockClient.cpp : 定义控制台应用程序的入口点。
/*
客户端为多线程工作方式，主线程显示用户的输入和数据的计算结果，子线程接收和发送数据
1.主线程用于所有的界面显示和接收用户的输入
2.建立一个数据发送线程，当数据打包后，通知该线程向服务器发送数据
3.建立一个数据接收线程。当该线程接收到服务器发送的数据后，由该线程完成对数据的解包，并通知主线程显示结果
4.所有的子线程都必须自动退出。在所有字线程都退出后，主线程最后退出
客户端退出：
客户端首先向服务器发送"byebye"或"Byebye"消息，然后等待服务器的返回消息。当客户端的接收数据线程收到服务器返回的"OK"消息后，通知主线程显示该消息。然后，主线程通知发送数据线程和接收数据线程退出。在确定这两个线程都退出后，主线程最后退出。
*/
#include <winsock2.h>
#include <stdio.h>
#include <iostream>
using namespace std;
#pragma  comment(lib,"ws2_32.lib")
 
#define  TIMEFOR_THREAD_EXIT 1000
#define  TIMEFOR_THREAD_SLEEP 500
#define  BUF_MAX_NUM 64
#define  HEADERLEN (sizeof(hdr))
typedef struct _head//数据包包头结构该结构在win32xp下为4byte
{
    char type;//类型
    unsigned short len;//数据包的长度(包括头的长度)
}hdr,*phdr;
typedef struct _data//数据包中的数据结构
{
    char buf[BUF_MAX_NUM];
}DATABUF,*pDataBuf;
//数据包：包头(类型[2byte]+长度[2byte])+数据；

SOCKET sClient;//套接字
HANDLE hThreadSend;//发送数据线程
HANDLE hThreadRecv;//接收数据线程
DATABUF bufSend;//发送数据缓冲区
DATABUF bufRecv;//接收数据缓冲区
CRITICAL_SECTION csSend;//当读写 bufSend变量时，要在之前进入临界区，之后退出临界区;//临界区对象，锁定bufSend
CRITICAL_SECTION csRecv;//当读写 bufRecv变量时，要在之前进入临界区，之后退出临界区;//临界区对象，锁定bufRecv

BOOL bSendData;//通知发送数据线程发送数据
HANDLE hEventShowDataResult;//显示计算结果的事件
BOOL bConnected;//与服务器的连接状态
HANDLE arrThread[2];//子线程数组

BOOL InitClient();//初始化
BOOL ConnectServer();//连接服务器
BOOL CreateSendAndRecvThread();//创建发送和接收数据线程
void InputAndOutput();//用户输入数据和显示结果
void ExitClient();//退出

void InitMember();//初始化全局变量
BOOL  InitSocket();//创建SOCKET

DWORD _stdcall RecvDataThread(LPVOID pParam);//接收数据线程
DWORD _stdcall SendDataThread(LPVOID pParam);//发送数据线程

BOOL PackByebye(const char* pExpr);//将输入的"Byebye","byebye"字符串打包
BOOL PackExpression(const char* pExpr);//将输入的算数表达式打包

void ShowConnectMsg(BOOL bConnected);//显示连接服务器消息
void ShowDataResultMsg();//显示计算结果
void ShowTipMsg(BOOL bFirstInput);//显示提示信息

int main()
{ 
    if (!InitClient())
    {
        ExitClient();
        return 0;
    } 
    if (ConnectServer())
    {
        ShowConnectMsg(TRUE);
    }
    else
    {
        ShowConnectMsg(FALSE);
        ExitClient();
        return 0;
    }   
    if (!CreateSendAndRecvThread()) //创建发送和接收数据线程
    {
        ExitClient();
        return 0;
    }
	InputAndOutput();//用户输入数据和显示结果    
    ExitClient();//退出
	system("pause");
	return 0;
}
BOOL InitClient()//初始化
{
    InitMember();
    if (!InitSocket())
    {
        return FALSE;
    }
    return TRUE;
}
void InitMember()//初始化全局变量
{
    InitializeCriticalSection(&csSend);
    InitializeCriticalSection(&csRecv);

    sClient=INVALID_SOCKET;
    hThreadRecv=NULL;
    hThreadSend=NULL;
    bConnected=FALSE;
    bSendData=FALSE;

    memset(bufRecv.buf,0,BUF_MAX_NUM);
    memset(bufSend.buf,0,BUF_MAX_NUM);

	//手动设置事件，初始化为无信号状态
    hEventShowDataResult=(HANDLE)CreateEvent(NULL,TRUE,FALSE,NULL);
}
BOOL  InitSocket()//创建SOCKET
{
    WSADATA wsd;
    if (WSAStartup(MAKEWORD(2,2),&wsd) != 0)
    {
        return FALSE;
    }

    if ((sClient=socket(AF_INET,SOCK_STREAM,0)) == INVALID_SOCKET)
    {
        return FALSE;
    }

    //设置套接字为非阻塞模式
    unsigned long ul=1;
    if (ioctlsocket(sClient,FIONBIO,&ul) == SOCKET_ERROR)
    {
        return FALSE;
    }
    return TRUE;
}
BOOL ConnectServer()//连接服务器
{
    SOCKADDR_IN addrServ;
    addrServ.sin_family=AF_INET;
    addrServ.sin_addr.s_addr=inet_addr("127.0.0.1");
    addrServ.sin_port=htons(5000);
    int reVal;
    while (1)
    { 
        reVal=connect(sClient,(SOCKADDR*)&addrServ,sizeof(addrServ));
		//处理连接错误。当使用非阻塞套接字时，建议最好不要使用这种方法来判断客户端是否成功连接服务器。推荐使用select(),WSAAsyncSelect()或者WSAEventselect()，来判断连接服务器是否成功。在后面的章节中会讲解到。
        if (reVal == SOCKET_ERROR)
        {
            int nErrCode=WSAGetLastError();
            if (nErrCode == WSAEWOULDBLOCK || nErrCode == WSAEINVAL)//连接未能够立即完成；监听状态
            {
                continue;
            }
            else if (nErrCode == WSAEISCONN)//连接已经完成
            {
                break;
            }
            else//其他原因，连接失败
            {
                return FALSE;
            }
        }
        if(reVal == 0)//连接成功
        {
            break;
        }
    }
    bConnected=TRUE;
    return TRUE;
}
BOOL CreateSendAndRecvThread()//创建发送和接收数据线程
{
    unsigned long ulThreadId;
    if ((hThreadRecv=CreateThread(NULL,0,RecvDataThread,NULL,0,&ulThreadId)) == NULL)
    {
        return FALSE;
    }
    if ((hThreadSend=CreateThread(NULL,0,SendDataThread,NULL,0,&ulThreadId)) == NULL)
    {
        return FALSE;
    }
    arrThread[0]=hThreadRecv;
    arrThread[1]=hThreadSend;
    return TRUE;
}
/* 客户端退出
客户端首先向服务器发送"Byebye","byebye"消息，然后等待服务器的返回消息。当客户端的接收数据线程收到服务器返回的"OK"消息后，通知主线程显示该消息。然后，主线程通知发送数据线程和接收数据线程退出。在确认这两个线程都退出后，主线程最后退出。
*/
void InputAndOutput()//用户输入数据和显示结果
{
	char cInput[BUF_MAX_NUM];//用户输入缓冲区
	BOOL bFirstInput=TRUE;//第一次只能输入算术表达式
	while(bConnected)//连接状态
	{
		memset(cInput,0,BUF_MAX_NUM);
		ShowTipMsg(bFirstInput);//提示输入信息
		cin >> cInput;
		char* pTemp=cInput;
		if (bFirstInput)//第一次输入
		{
			if (!PackExpression(pTemp))//算数表达式打包
			{
				continue;//重新输入
			}
			bFirstInput = FALSE;//成功输入第一个算数表达式
		}
		else if (!PackByebye(pTemp))//Byebye byebye 打包
		{
			if (!PackExpression(pTemp))//算数表达式打包
			{
				continue;//重新输入
			}
		}
		//等待显示结果
		if (WAIT_OBJECT_0 == WaitForSingleObject(hEventShowDataResult,INFINITE))
		{
			ResetEvent(hEventShowDataResult);//设置为无信号状态	
			if (!bConnected)//客户端被动退出，此时接收和发送数据线程已经退出。
			{
				break;
			}
			ShowDataResultMsg();//显示数据
			if (0 == strcmp(bufRecv.buf,"OK"))//客户端主动退出
			{
				bConnected=FALSE;
				Sleep(TIMEFOR_THREAD_EXIT);//给数据接收和发送线程退出时间
			}
		}
	}
	if (!bConnected)//与服务器连接已经断开
	{
		ShowConnectMsg(FALSE);//显示信息
	}
	//等待数据发送和接收线程退出;为了做到主线程最后退出
	if (WAIT_ABANDONED_0 == WaitForMultipleObjects(2,arrThread,TRUE,INFINITE))
	{
		int nErrCode=GetLastError();
	}
}
void ExitClient()//退出
{
    DeleteCriticalSection(&csSend);
    DeleteCriticalSection(&csRecv);
    CloseHandle(hThreadRecv);
    CloseHandle(hThreadSend);
    closesocket(sClient);
    WSACleanup();
}

DWORD _stdcall RecvDataThread(LPVOID pParam)//接收数据线程
{
	int reVal;
	char temp[BUF_MAX_NUM];
	memset(temp,0,BUF_MAX_NUM);
	while(bConnected)//连接状态	
	{
		reVal = recv( sClient,temp,BUF_MAX_NUM,0);//接收数据
		if ( SOCKET_ERROR == reVal)//接受数据缓冲区不可用
		{
			int nErrCode = WSAGetLastError();
			if (WSAEWOULDBLOCK == nErrCode)
			{
				Sleep(TIMEFOR_THREAD_SLEEP);//线程睡眠
				continue;//继续接收数据
			}
			else
			{
				bConnected = FALSE;
				SetEvent(hEventShowDataResult);//通知主线程，防止在无限期的等待
				return 0;//线程退出	
			}
		}
		if ( 0 == reVal)//服务器关闭了连接
		{
			bConnected = FALSE;//线程退出	
			SetEvent(hEventShowDataResult);//通知主线程，防止在无限期的等待
			return 0;//线程退出	
		}
		if ( reVal > HEADERLEN && reVal != -1)//收到数据
		{
			//对数据解包
			phdr header =(phdr)temp;
			EnterCriticalSection(&csRecv);
                        memset(bufRecv.buf,0,BUF_MAX_NUM);
			memcpy(bufRecv.buf,temp + HEADERLEN,header->len - HEADERLEN);//将数据结果复制到接收数据缓冲区
			LeaveCriticalSection(&csRecv);
			SetEvent(hEventShowDataResult);//通知主线程显示计算结果
			memset(temp,0,BUF_MAX_NUM);
		}
		Sleep(TIMEFOR_THREAD_SLEEP);//线程睡眠
	}
    return 0;
}
DWORD _stdcall SendDataThread(LPVOID pParam)//发送数据线程
{
	while(bConnected)//连接状态
	{
		if (bSendData)//发送数据
		{
			EnterCriticalSection(&csSend);//进入临界区
			while(TRUE)
			{
				int nBuflen=((phdr)bufSend.buf)->len;
				int val = send(sClient,bufSend.buf,nBuflen,0);
				//处理返回错误
				if (SOCKET_ERROR == val)
				{
					int nErrCode = WSAGetLastError();
					if (WSAEWOULDBLOCK == nErrCode)//发送缓冲区不可用
					{
						continue;//继续循环
					}
					else
					{
						LeaveCriticalSection(&csSend);//离开临界区
						bConnected = FALSE;//断开状态
						SetEvent(hEventShowDataResult);//通知主线程，防止在无限期的等待返回结果。
						return 0;
					}
				}
				bSendData = FALSE;//发送状态
				break;//跳出for
			}
			LeaveCriticalSection(&csSend);//离开临界区
		}
		Sleep(TIMEFOR_THREAD_SLEEP);//线程睡眠
	}
    return 0;
}
BOOL PackByebye(const char* pExpr)//将输入的"Byebye","byebye"字符串打包
{
	BOOL reVal = FALSE;
	if (!strcmp("Byebye",pExpr) || !strcmp("byebye",pExpr))
	{
		EnterCriticalSection(&csSend);
		phdr pHeader =(phdr)bufSend.buf;//强制转换
		pHeader->type='B';//类型
		pHeader->len = HEADERLEN + strlen("Byebye");//数据包长度
		memcpy(bufSend.buf + HEADERLEN,pExpr,strlen(pExpr));//复制数据
		LeaveCriticalSection(&csSend);
		pHeader = NULL;
		bSendData = TRUE;//通知发送数据线程
		reVal = TRUE;
	}
	return reVal; 
}
BOOL PackExpression(const char* pExpr)//将输入的算数表达式打包
{
	char* pTemp = (char*)pExpr;//算数表达式数字开始的位置
	while (!*pTemp)//第一个数字位置
	{
		pTemp++;
	}
	char* pos1=pTemp;
	char* pos2=NULL;
	char* pos3=NULL;
	int len1=0,len2=0,len3=0;
	if ((*pTemp != '+') && (*pTemp != '-') && ((*pTemp < '0') || (*pTemp > '9')))//第一个字符是+ - 或者是数字
	{
		return FALSE;
	}

	if ((*pTemp++ == '-')&&(*pTemp < '0' || *pTemp > '9'))	//第一个字符是'-',第二个是数字	
		return FALSE;										//重新输入
	--pTemp;												//上移指针

	char* pNum = pTemp;						//数字开始的位置					
	if (*pTemp == '+'||*pTemp == '-')		//+ -
		pTemp++;

	while (*pTemp >= '0' && *pTemp <= '9')	//数字
		pTemp++;							

	len1 = pTemp - pNum;//数字长度						

	//可能有空格
	while(!*pTemp)							
		pTemp++;

	//算数运算符
	if (('+' != *pTemp) && ('-' != *pTemp) &&	('*' != *pTemp) && ('/' != *pTemp))
		return FALSE;

	pos2 = pTemp;
	len2 = 1;

	//下移指针
	pTemp++;
	//可能有空格
	while(!*pTemp)
		pTemp++;

	//第2个数字位置
	pos3 = pTemp;
	if (*pTemp < '0' || *pTemp > '9')
		return FALSE;//重新输入			

	while (*pTemp >= '0' && *pTemp <= '9')//数字
		pTemp++;

	if ('=' != *pTemp)	//最后是等于号
		return FALSE;	//重新输入

	len3 = pTemp - pos3;//数字长度


	int nExprlen = len1 + len2 + len3;	//算数表示长度

	//表达式读入发送数据缓冲区
	EnterCriticalSection(&csSend);		//进入临界区
	//数据包头
	phdr pHeader = (phdr)(bufSend.buf);
	pHeader->type = 'E';			//类型
	pHeader->len = nExprlen + HEADERLEN;//数据包长度
	//拷贝数据
	memcpy(bufSend.buf + HEADERLEN, pos1, len1);
	memcpy(bufSend.buf + HEADERLEN + len1, pos2, len2);
	memcpy(bufSend.buf + HEADERLEN + len1 + len2 , pos3,len3);
	LeaveCriticalSection(&csSend);		//离开临界区
	pHeader = NULL;

	bSendData = TRUE;					//通知发送数据线程发送数据
    return TRUE;
}
void ShowConnectMsg(BOOL bSuc)//显示连接服务器失败消息
{
	if (bSuc)
	{ 
		cout << "* Succeed to connect server! *" << endl; 
	}
	else
	{ 
		cout << "* Fail to connect server! *" << endl; 
	}
}
void ShowDataResultMsg()//显示计算结果
{
	EnterCriticalSection(&csRecv); 
	cout << "***Result: "<<bufRecv.buf <<endl; 
	LeaveCriticalSection(&csRecv);
}
void ShowTipMsg(BOOL bFirstInput)//显示提示信息
{
	if (bFirstInput)//首次显示
	{
		cout << "**********************************" << endl;
		cout << "*                                *" << endl;
		cout << "* Please input expression.       *" << endl;
		cout << "* Usage:NumberOperatorNumber=    *" << endl;
		cout << "*                                *" << endl;
		cout << "**********************************" << endl;
	}else{
		cout << "**********************************" << endl;
		cout << "*                                *" << endl;
		cout << "* Please input: expression       *" << endl;
		cout << "* Usage:NumberOperatorNumber=    *" << endl;
		cout << "*                                *" << endl;
		cout << "* If you want to exit.           *" << endl;
		cout << "* Usage: Byebye or byebye        *" << endl;
		cout << "*                                *" << endl;
		cout << "**********************************" << endl;
	}	
}

运行结果：

你可能感兴趣的:([精通WindowsSocket网络开发-基于VC++实现]第五章——非阻塞模式开发)

MyBatis中SQL写法总结是Cc哈 mybatis sql
最近MyBatis使用较多，在这里简单总结一下MyBatis的sql写法说简单⼀点mybatis就是写原⽣sql，官⽅都说了mybatis的动态sql语句是基于OGNL表达式的。可以⽅便的在sql语句中实现某些逻辑.总体说来mybatis动态SQL语句主要有以下⼏类:if语句(简单的条件判断)choose(when,otherwize),相当于java语⾔中的switch,与jstl中的choos
Wayland开发入门系列3：Wayland架构幽迷狂 Wayland开发入门 wayland linux desktop
本文译自https://wayland.freedesktop.org/architecture.html。翻译时间：2021.09.27Wayland架构理解Wayland架构以及它与X不同的好方法是跟踪一个事件从输入设备到它所影响的变化出现在屏幕上的程度。下面是与X的架构：1.内核从输入设备获取一个事件，并通过evdev输入驱动程序将其发送给X。内核通过驱动设备并将不同设备特定的事件协议转换为
算法题解：数据流中的中位数琴瑟和鸣1 算法学习数据流中的中位数算法剑指offer
题目描述如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。我们使用Insert()方法读取数据流，使用GetMedian()方法获取当前读取数据的中位数。代码实现importjava.util.*;publicclassSolution{//按照题目中描述，是要所
5步打造完善的物联网IoT测试体系 moton2017 物联网可用性测试 iot 物联网测试测试体系测试工具
前言智能硬件和软件测试规范涉及概述用于测试系统功能、性能和可靠性的详细说明和标准，以帮助确保系统的可靠性和质量。请记住，测试是一个迭代过程，需要根据项目不断发展的性质进行调整。一、物联网测试流程概览测试基本流程物联网测试基本流程阶段流程版本开发需求分析>编写测试计划>编写测试用例>用例评审版本测试研发自测>提测>第一轮测试>bug管理>修改bug>第二轮测试>修改bug>第三轮测试版本上线提交版本
物联网名词----物模型、设备影子 moton2017 物联网
在物联网(IoT)背景下，术语“物模型”和“设备影子”是指与管理和表示连接设备相关的概念。物模型：IoT中的物模型表示IoT实体或事物的结构和行为。它定义了数据和功能如何在物联网生态系统中组织和交互。物模型指定与IoT对象相关的属性、方法和关系，从而实现与设备通信和交互的标准化方式。这有助于实现不同物联网设备和系统的互操作性和无缝集成。设备影子：设备影子是物联网平台中常用的概念，用于维护物理物联网
linux-LAMP搭建 Theshaye linux系统服务器 linux apache
LAMP1.架构描述LAMP是一个C/S架构的平台：web客户端基于tcp/ip协议，发出http请求，服务端进行回应，用户的请求可能是动态的也可能是静态的。web服务器通过用户发送的url后缀判断动静态请求：静态请求web服务器直接处理静态请求web服务器转发给后台应用服务器去处理：(CGI)php运行的后台程序apache与php所处环境不同决定其通讯方式不同：安装在同一台服务器，就默认使用系
Python 实现车牌识别菜狗小测试 Python技术专栏 python 计算机视觉 opencv
一、车牌识别的基本原理车牌识别主要包括以下几个步骤：图像采集：通过摄像头或其他图像采集设备获取包含车牌的图像。图像预处理：对采集到的图像进行灰度化、滤波、增强等操作，以提高图像的质量和清晰度，便于后续的处理。车牌定位：从预处理后的图像中找出车牌的位置。这可以通过一些特征提取和机器学习算法来实现，例如基于颜色特征、边缘特征等方法来定位车牌区域。字符分割：将定位到的车牌区域中的字符分割开，以便对每个字
深入解析Vue3响应式系统：从Proxy实现到依赖收集的核心原理荆州克莱面试题汇总与解析 spring cloud spring boot spring 技术 css3
深入解析Vue3响应式系统：从Proxy实现到依赖收集的核心原理响应式系统的基本原理作为一个热门的JavaScript框架，Vue在3.x版本中引入了基于Proxy的响应式系统。这个系统的核心思想是利用Proxy对象拦截对数据的访问和修改，从而实现数据的自动更新。当我们改变一个被代理的对象时，相关的视图会自动更新，无需手动干预。这一创新的设计让Vue3在性能和开发体验上都有了大幅度的改进。如何实现
微服务网关springcloud gateway整合nacos实现动态路由程序猿20 nacos 微服务 springcloud gateway nacos 微服务
1.添加依赖com.alibaba.cloudspring-cloud-starter-alibaba-nacos-config2.添加配置spring:cloud:nacos:config:#配置中心地址server-addr:127.0.0.1:8848#配置文件格式file-extension:ymlusername:password:3.定义读取配置和监听类packagecom.demo.
@JsonCreator 注解 huang_hai_an java ajax javascript
@JsonCreator注解是Jackson库中用于指定如何从JSON数据创建Java对象实例的一个重要工具。它允许你定义一个静态方法（通常是构造函数或静态工厂方法），Jackson在反序列化时会调用这个方法来生成对象实例。@JsonCreator注解可以应用于方法、构造函数或注解类型，并且可以通过mode()属性指定不同的工作模式。@JsonCreator注解的组成部分@Target:指定该注解
论云原生架构及其应用一休哥助手架构软考系统架构师云原生架构 perl
一、引言随着云计算技术的发展，企业在应用开发和运维中逐步向云端迁移，从传统单体架构向云原生架构演进。云原生架构（CloudNativeArchitecture）是一种利用云计算的本质特性设计的架构，其核心理念是利用微服务、容器编排、自动化运维等技术手段，以支持应用的高扩展性、稳定性和快速部署。云原生架构的核心设计原则包括服务化、韧性、可观测性和自动化，这些原则为云端应用的高效运行奠定了坚实的基础。
ESP32内存管理详解：从基础到进阶又吹风_Bassy ESP32 内存管理 PSRAM DRAM FLASH
最近在学习ESP32，下面整理了一些存储和内存相关知识点。ESP32作为一款功能强大的物联网芯片，广泛应用于各种嵌入式开发场景。有效管理ESP32的内存资源，对于提升应用性能和系统稳定性至关重要。本文将系统性地介绍ESP32的内存架构、存储硬件知识、内存分配机制、常见内存问题及解决方案，帮助新手开发者全面掌握ESP32的内存管理。一、内存系统概览1.1ESP32内存架构ESP32的内存架构复杂而灵
Qt调用FFmpeg库实时播放UDP组播视频流 daqinzl qt ffmpeg 流媒体 qt ffmpeg udp组播流
基于以下参考链接，通过改进实现实时播放UDP组播视频流https://blog.csdn.net/u012532263/article/details/102736700源码在windows（qt-opensource-windows-x86-5.12.9.exe）、ubuntu20.04.6(x64)(qt-opensource-linux-x64-5.12.12.run)、以及针对arm64的
Solon Cloud Gateway 开发：熟悉 Completable 响应式接口组合缺一 Solon Java Framework gateway solon java reactor
Solon-Rx（约2Kb）是基于reactive-streams封装的RxJava极简版（约2Mb左右）。目前仅一个接口Completable，意为：可完成的发布者。使用场景及接口：接口说明Completable作为返回类型Completable::complete()构建完成发布者Completable::error(cause)构建异常发布者Completable::create(（emit
Solon2 接口开发: 熟悉 Gateway 组合缺一 Solon Java Framework gateway java solon
Gateway是Solon框架的特殊控制器（也是Handler的一个实现类）。它通过注册收集之后，在局部范围内提供：二级路由、拦截、过滤、融断、异常处理等功能，并统一到网关处理。另一个作用：可以为同一批接口安排多个网关，进而定制不同的协议效果。1、定义2个组件API_0@Component(tag="api")publicclassAPI_0{@MappingpublicResultexec(){
Solon Cloud Gateway 开发：熟悉 ExContext 及相关接口组合缺一 Solon Java Framework gateway solon java 后端
分布式网关的主要工作是路由及数据交换，在定义时，会经常用到：接口说明RouteFilterFactory路由过滤器工厂RoutePredicateFactory路由检测器工厂CloudGatewayFilter分布式网关过滤器ExFilter交换过滤器ExPredicate交换检测器ExContext交换上下文ExFilter应用场景CloudGatewayFilterextendsExFilte
计算机毕业设计ssm旅游景点推荐系统02d989（附源码）新手必备毕设程序源码课程设计
项目运行环境配置：Jdk1.8+Tomcat7.0+Mysql+HBuilderX（Webstorm也行）+Eclispe（IntelliJIDEA,Eclispe,MyEclispe,Sts都支持）。项目技术：ssm+mybatis+Maven+mysql5.7或8.0等等组成，B/S模式+Maven管理等等。环境需要1.运行环境：最好是javajdk1.8，我们在这个平台上运行的。其他版本理论
RiskCloud-基于Markov算法精准的FTA、 JSA、FMEA软件资讯过客视点算法
这个美美的“花蝴蝶”是什么?样式规整、图案美化、脉络清晰、让人眼前一亮!由上海歌略软件科技有限公司自主研发打造,RiskCloud世界领先的企业级整体风险管理解决方案大作!“BowTie领结图”接下来,就让我们携手一起走进RiskCloud-BowTie领结图,一起领略她的风采吧!风险管理领结图介绍20世纪90年代末,领结图作为一种独特的安全管理工具,开始在国外石油化工领域得到较为广泛的应用。基于
Spring Cloud Gateway 动态路由加载：使用 Nacos 实现动态路由配置 Takumilovexu 微服务 java spring cloud 开发语言
文章目录背景介绍代码实现关键步骤解析总结在微服务架构中，路由配置的动态更新是非常重要的环节。通过动态路由，我们可以在不重启服务的情况下，灵活地增加、修改或删除路由配置。今天，我将分享如何在SpringCloudGateway中使用Nacos实现动态路由配置的实现方法。背景介绍在日常开发中，经常遇到运行时动态管理路由配置的需求。传统方式通常需要重启网关服务，这显然不够优雅且效率较低。为了解决这个问题
什么是iPaaS？谷云科技RestCloud iPaaS 混合集成平台数字化转型
一、iPaaS简介iPaaS，即集成平台即服务（IntegrationPlatformasaService），是一种基于云计算的自助服务模型，它为企业提供了一种标准化的应用程序集成方式。能够促进开发、执行和治理集成流程，连接本地和云基础的流程、服务、应用和数据。iPaaS的核心价值在于使技术专业人员甚至非技术人员能够快速构建集成流程，实现企业内部数据的互联互通。二、企业集成方式的演变随着企业信息化
【车牌识别】卷积神经网络CNN车牌识别【含 GUI Matlab源码 2638期】 Matlab仿真科研站 matlab
欢迎来到Matlab仿真科研站博客之家✅博主简介：热爱科研的Matlab仿真开发者，修心和技术同步精进，Matlab项目合作可私信。个人主页：Matlab仿真科研站博客之家代码获取方式：扫描文章底部QQ二维码⛳️座右铭：行百里者，半于九十；路漫漫其修远兮，吾将上下而求索。⛄更多Matlab图像处理（仿真科研站版）仿真内容点击Matlab图像处理（仿真科研站版）⛄一、CNN车牌识别简介1车牌定位1.
MyBatis技术详解与实战小码快撩 mybatis java 开发语言
引言MyBatis是一款优秀的Java持久层框架，它支持定制化SQL、存储过程以及高级映射。MyBatis避免了几乎所有的JDBC代码和手动设置参数以及获取结果集的工作，使开发者能更专注于对业务逻辑的实现。本文将详细介绍MyBatis的核心概念，并通过示例代码进行深入讲解。一、配置文件MyBatis配置文件（通常命名为mybatis-config.xml）是MyBatis框架的核心配置文件，它定义
基于Docker搭建Sentinel Dashboard smart_ljh 工具 docker sentinel 容器流控平台
从官网下载sentineljar文件在与sentinel-dashboard-1.8.8.jar同一目录创建Dockerfile文件构建docker镜像文件创建镜像tag包提交镜像至镜像仓库下面就可以部署sentinel-dashboard容器了验证sentinel-dashboard控制台是否可用Sentinel是一个开源的分布式流量控制与熔断框架，由阿里巴巴集团开源，主要用于保护微服务架构中的
SpringCloud系列教程：微服务的未来（十七）监听Nacos配置变更、更新路由、实现动态路由程序猿零零漆 SpringCloud专栏 spring cloud 微服务 java
前言在微服务架构中，API网关是各个服务之间的入口点，承担着路由、负载均衡、安全认证等重要功能。为了实现动态的路由配置管理，通常需要通过中心化的配置管理系统来实现灵活的路由更新，而无需重启网关服务。Nacos作为一个开源的动态服务发现与配置管理平台，可以方便地实现这一目标。本文将介绍如何利用Nacos配置中心来动态更新SpringCloudGateway的路由配置，确保路由信息的实时更新，并提升系
为Linux aarch64架构量身定制的JDK 8 Update 321：高效开发的首选黄弛纯Nathania
为Linuxaarch64架构量身定制的JDK8Update321：高效开发的首选【下载地址】JDK8Update321forLinuxaarch64下载仓库JDK8Update321forLinux(aarch64)下载仓库项目地址:https://gitcode.com/open-source-toolkit/0d9e1项目介绍在Linux操作系统上进行Java开发时，选择合适的JDK版本至关
深入解析ncnn::Net类——高效部署神经网络的核心组件又吹风_Bassy 人工智能深度学习 ncnn ncnn Net ncnn使用示例
最近在学习ncnn推理框架，下面整理了ncnn::Net的使用方法。在移动端和嵌入式设备上进行高效的神经网络推理，要求框架具备轻量化、高性能以及灵活的扩展能力。作为腾讯开源的高性能神经网络推理框架，ncnn在这些方面表现出色。而在ncnn的核心组件中，ncnn::Net类扮演了至关重要的角色。本文将详细介绍ncnn::Net类的结构、功能及其使用方法，帮助开发者更好地理解和利用这一强大的工具。目录
带你简单认识真实场景下的Git版本控制流程 gitgithub
‍Git版本控制-HowieCong1.项目初始化与仓库创建gitinit命令初始化一个本地git仓库在github创建一个远程仓库，将本地仓库与远程仓库，gitremoteaddorigin[远程仓库地址]2.分支管理策略（采用常用的分支开发模式）以master或main为主分支，存放稳定可上线的代码开发新功能的代码时，从master分支创建特性分支，例如feature/[功能名称]，在特性分支
python实现dbscan 怎么就重名了算法 python 开发语言
python实现dbscan原理DBSCAN(Density-BasedSpatialClusteringofApplicationswithNoise)是一个比较有代表性的基于密度的聚类算法。它将簇定义为密度相连的点的最大集合，能够把具有足够高密度的区域划分为簇，并可在噪声的空间数据库中发现任意形状的聚类。DBSCAN中的几个定义：Ε邻域：给定对象半径为Ε内的区域称为该对象的Ε邻域；核心对象：如
控制webview_flutter导航条返回键行为 jocchoc Flutter flutter webview_flutter 路由
作为一名web开发人员，也按耐不住来蹭一波flutter的热度。项目中要求用flutter嵌套web，此处采用webview_flutter插件【官方文档】。插件的使用方法不做赘述。此处分享：如何控制内嵌web的返回键行为，返回web上一路由or退出webview?1.自制导航条由于webview_flutter没有封装导航条，首先我们需要自制一个带有返回箭头的导航条。returnnewScaff
动物判别系统python实现 L C H python 人工智能算法矩阵线性代数
动物判别系统由于明天的实验时间较为紧张，所以本人提前完成实验，将代码呈现如下（有些许参考）：由于明天的实验时间较为紧张，所以本人提前完成实验，将代码呈现如下（有些许参考）：#判断有无重复元素defjudge_repeat(value,list=[]):foriinrange(0,len(list)):if(list[i]==value):return1else:if(i!=len(list)-1)
矩阵求逆（JAVA）初等行变换 qiuwanchi 矩阵求逆（JAVA）
package gaodai.matrix; import gaodai.determinant.DeterminantCalculation; import java.util.ArrayList; import java.util.List; import java.util.Scanner; /** * 矩阵求逆(初等行变换) * @author 邱万迟 *
JDK timer antlove java jdk schedule code timer
1.java.util.Timer.schedule(TimerTask task, long delay)：多长时间（毫秒）后执行任务 2.java.util.Timer.schedule(TimerTask task, Date time)：设定某个时间执行任务 3.java.util.Timer.schedule(TimerTask task, long delay,longperiod
JVM调优总结 -Xms -Xmx -Xmn -Xss coder_xpf jvm 应用服务器
堆大小设置JVM 中最大堆大小有三方面限制：相关操作系统的数据模型（32-bt还是64-bit）限制；系统的可用虚拟内存限制；系统的可用物理内存限制。32位系统下，一般限制在1.5G~2G；64为操作系统对内存无限制。我在Windows Server 2003 系统，3.5G物理内存，JDK5.0下测试，最大可设置为1478m。典型设置： java -Xmx
JDBC连接数据库 Array_06 jdbc
package Util; import java.sql.Connection; import java.sql.DriverManager; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; public class JDBCUtil { //完
Unsupported major.minor version 51.0（jdk版本错误） oloz java
java.lang.UnsupportedClassVersionError: cn/support/cache/CacheType : Unsupported major.minor version 51.0 (unable to load class cn.support.cache.CacheType) at org.apache.catalina.loader.WebappClassL
用多个线程处理1个List集合 362217990 多线程 thread list 集合
昨天发了一个提问，启动5个线程将一个List中的内容，然后将5个线程的内容拼接起来，由于时间比较急迫，自己就写了一个Demo，希望对菜鸟有参考意义。。 import java.util.ArrayList; import java.util.List; import java.util.concurrent.CountDownLatch; public c
JSP简单访问数据库香水浓 sql mysql jsp
学习使用javaBean，代码很烂，仅为留个脚印 public class DBHelper { private String driverName; private String url; private String user; private String password; private Connection connection; privat
Flex4中使用组件添加柱状图、饼状图等图表 AdyZhang Flex
1.添加一个最简单的柱状图 ? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 <?xml version= "1.0"&n
Android 5.0 - ProgressBar 进度条无法展示到按钮的前面 aijuans android
在低于SDK < 21 的版本中，ProgressBar 可以展示到按钮前面，并且为之在按钮的中间，但是切换到android 5.0后进度条ProgressBar 展示顺序变化了，按钮再前面，ProgressBar 在后面了我的xml配置文件如下： [html] view plain copy <RelativeLa
查询汇总的sql baalwolf sql
select list.listname, list.createtime,listcount from dream_list as list , (select listid,count(listid) as listcount from dream_list_user group by listid order by count(
Linux du命令和df命令区别 BigBird2012 linux
1，两者区别 du，disk usage,是通过搜索文件来计算每个文件的大小然后累加，du能看到的文件只是一些当前存在的，没有被删除的。他计算的大小就是当前他认为存在的所有文件大小的累加和。
AngularJS中的$apply，用还是不用？ bijian1013 JavaScript AngularJS $apply
在AngularJS开发中，何时应该调用$scope.$apply()，何时不应该调用。下面我们透彻地解释这个问题。但是首先，让我们把$apply转换成一种简化的形式。 scope.$apply就像一个懒惰的工人。它需要按照命
[Zookeeper学习笔记十]Zookeeper源代码分析之ClientCnxn数据序列化和反序列化 bit1129 zookeeper
ClientCnxn是Zookeeper客户端和Zookeeper服务器端进行通信和事件通知处理的主要类，它内部包含两个类，1. SendThread 2. EventThread， SendThread负责客户端和服务器端的数据通信，也包括事件信息的传输，EventThread主要在客户端回调注册的Watchers进行通知处理 ClientCnxn构造方法 &
【Java命令一】jmap bit1129 Java命令
jmap命令的用法： [hadoop@hadoop sbin]$ jmap Usage: jmap [option] <pid> (to connect to running process) jmap [option] <executable <core> (to connect to a
Apache 服务器安全防护及实战 ronin47
此文转自IBM. Apache 服务简介 Web 服务器也称为 WWW 服务器或 HTTP 服务器 (HTTP Server)，它是 Internet 上最常见也是使用最频繁的服务器之一，Web 服务器能够为用户提供网页浏览、论坛访问等等服务。由于用户在通过 Web 浏览器访问信息资源的过程中，无须再关心一些技术性的细节，而且界面非常友好，因而 Web 在 Internet 上一推出就得到
unity 3d实例化位置出现布置？ brotherlamp unity教程 unity unity资料 unity视频 unity自学
问：unity 3d实例化位置出现布置？答：实例化的同时就可以指定被实例化的物体的位置,即 position Instantiate (original : Object, position : Vector3, rotation : Quaternion) : Object 这样你不需要再用Transform.Position了, 如果你省略了第二个参数(
《重构，改善现有代码的设计》第八章 Duplicate Observed Data bylijinnan java 重构
import java.awt.Color; import java.awt.Container; import java.awt.FlowLayout; import java.awt.Label; import java.awt.TextField; import java.awt.event.FocusAdapter; import java.awt.event.FocusE
struts2更改struts.xml配置目录 chiangfai struts.xml
struts2默认是读取classes目录下的配置文件，要更改配置文件目录，比如放在WEB-INF下，路径应该写成../struts.xml(非/WEB-INF/struts.xml) web.xml文件修改如下： <filter> <filter-name>struts2</filter-name> <filter-class&g
redis做缓存时的一点优化 chenchao051 redis hadoop pipeline
最近集群上有个job，其中需要短时间内频繁访问缓存，大概7亿多次。我这边的缓存是使用redis来做的，问题就来了。首先，redis中存的是普通kv，没有考虑使用hash等解结构，那么以为着这个job需要访问7亿多次redis，导致效率低，且出现很多redi
mysql导出数据不输出标题行 daizj mysql 数据导出去掉第一行去掉标题
当想使用数据库中的某些数据，想将其导入到文件中，而想去掉第一行的标题是可以加上-N参数如通过下面命令导出数据： mysql -uuserName -ppasswd -hhost -Pport -Ddatabase -e " select * from tableName" > exportResult.txt 结果为： studentid
phpexcel导出excel表简单入门示例 dcj3sjt126com PHP Excel phpexcel
先下载PHPEXCEL类文件，放在class目录下面，然后新建一个index.php文件，内容如下 <?php error_reporting(E_ALL); ini_set('display_errors', TRUE); ini_set('display_startup_errors', TRUE); if (PHP_SAPI == 'cli') die('
爱情格言 dcj3sjt126com 格言
1) I love you not because of who you are, but because of who I am when I am with you. 　　我爱你，不是因为你是一个怎样的人，而是因为我喜欢与你在一起时的感觉。 　　2) No man or woman is worth your tears, and the one who is, won‘t
转 Activity 详解——Activity文档翻译 e200702084 android UI sqlite 配置管理网络应用
activity 展现在用户面前的经常是全屏窗口，你也可以将 activity 作为浮动窗口来使用（使用设置了 windowIsFloating 的主题），或者嵌入到其他的 activity （使用 ActivityGroup ）中。当用户离开 activity 时你可以在 onPause() 进行相应的操作。更重要的是，用户做的任何改变都应该在该点上提交 ( 经常提交到 ContentPro
win7安装MongoDB服务 geeksun mongodb
1. 下载MongoDB的windows版本：mongodb-win32-x86_64-2008plus-ssl-3.0.4.zip，Linux版本也在这里下载，下载地址： http://www.mongodb.org/downloads 2. 解压MongoDB在D:\server\mongodb, 在D:\server\mongodb下创建d
Javascript魔法方法:__defineGetter__,__defineSetter__ hongtoushizi js
转载自： http://www.blackglory.me/javascript-magic-method-definegetter-definesetter/ 在javascript的类中,可以用defineGetter和defineSetter_控制成员变量的Get和Set行为例如,在一个图书类中,我们自动为Book加上书名符号: function Book(name){
错误的日期格式可能导致走nginx proxy cache时不能进行304响应 jinnianshilongnian cache
昨天在整合某些系统的nginx配置时，出现了当使用nginx cache时无法返回304响应的情况，出问题的响应头： Content-Type:text/html; charset=gb2312 Date:Mon, 05 Jan 2015 01:58:05 GMT Expires:Mon , 05 Jan 15 02:03:00 GMT Last-Modified:Mon, 05
数据源架构模式之行数据入口 home198979 PHP 架构行数据入口
注：看不懂的请勿踩，此文章非针对java，java爱好者可直接略过。一、概念行数据入口（Row Data Gateway）：充当数据源中单条记录入口的对象，每行一个实例。二、简单实现行数据入口为了方便理解，还是先简单实现： <?php /** * 行数据入口类 */ class OrderGateway { /*定义元数
Linux各个目录的作用及内容 pda158 linux 脚本
1）根目录“/” 　　根目录位于目录结构的最顶层，用斜线（/）表示，类似于 Windows 操作系统的“C:\“，包含Fedora操作系统中所有的目录和文件。　　2）/bin 　　/bin 　　目录又称为二进制目录，包含了那些供系统管理员和普通用户使用的重要 linux命令的二进制映像。该目录存放的内容包括各种可执行文件，还有某些可执行文件的符号连接。常用的命令有：cp、d
ubuntu12.04上编译openjdk7 ol_beta HotSpot jvm jdk OpenJDK
获取源码从openjdk代码仓库获取(比较慢) 安装mercurial Mercurial是一个版本管理工具。 sudo apt-get install mercurial 将以下内容添加到$HOME/.hgrc文件中，如果没有则自己创建一个： [extensions] forest=/home/lichengwu/hgforest-crew/forest.py fe
将数据库字段转换成设计文档所需的字段 vipbooks 设计模式工作正则表达式
哈哈，出差这么久终于回来了，回家的感觉真好！ PowerDesigner的物理数据库一出来，设计文档中要改的字段就多得不计其数，如果要把PowerDesigner中的字段一个个Copy到设计文档中，那将会是一件非常痛苦的事情。