VC 多线程编写

#include <windows.h>
#include <iostream.h>

DWORD WINAPI fun1(LPVOID lpParameter);
DWORD WINAPI fun2(LPVOID lpParameter);


int tickets = 100;
CRITICAL_SECTION g_cs;

void main()
{

	HANDLE hThread1;
	HANDLE hThread2;

	hThread1 = CreateThread(NULL,0,fun1,NULL,0,NULL);
	hThread2 = CreateThread(NULL,0,fun2,NULL,0,NULL); //第四个参数可以来传递变量从主线程进入到fun线程。
	CloseHandle(hThread1);//关掉线程句柄，不是关掉线程本身。
	CloseHandle(hThread2);
	
	InitializeCriticalSection(&g_cs);

	Sleep(1000);

	DeleteCriticalSection(&g_cs);
}

DWORD WINAPI fun1(LPVOID IpParameter)
{

	while(TRUE)
	{

		EnterCriticalSection(&g_cs);
		if (tickets >0)	
		{
			cout<<"thread1 sell ticket : "<<tickets--<<endl;
			LeaveCriticalSection(&g_cs);
		}
		else 
		{
			break;
			LeaveCriticalSection(&g_cs);
		}

	}
	
	return 0;
}

DWORD WINAPI fun2(LPVOID IpParameter)
{

	while(TRUE)
	{
		EnterCriticalSection(&g_cs);

		if (tickets >0)	
		{
			cout<<"thread2 sell ticket : "<<tickets--<<endl;
			LeaveCriticalSection(&g_cs);
		}
		else 
		{
			break;
			LeaveCriticalSection(&g_cs);
		}

	}
	return 0;
}

如上程序，在主线程里面定义两个线程，分别从fun1和fun2开始执行。线程是利用时间片来共享一个CPU时间的，因为CPU运行速度够快，所以我们认为两个线程是并行执行的。然后利用关键代码段来实现进程互斥。对于一个全局变量来说，在各个进程中都有被用到，需要在A进程用到的时候，其他进程不能使用，不然变量就乱了。

在A进程中使用

EnterCriticalSection(&g_cs);
进入关键代码段，当其他进程遇到同样的EnterCriticalSection(&g_cs);时候，会等待g_cs的释放。所以其他进程就进入等待状态。
然后A进程使用完全局变量。释放g_cs
LeaveCriticalSection(&g_cs);

用VC MFC写的一个使用socket接受图片，然后显示图片两个进程。

其中使用一个ALL_BUFFER结构的全局变量来连接两个进程，使用关键代码段来保持这两个进程的互斥。

ALL_BUFFER结构中有100个指向char的指针，当然这个100可以更改。

当接受到图片后，把当前图片保存在的buffer复制到ALL_BUFFER的第一个指针去，然后来更多就都存进去。

然后另外一个线程从这个ALL_BUFFER中取出buffer显示出来。

所以简单来说就是一个线程只管接受，一个线程只管显示。公用一个char*型的数组（栈）。

这也达到了数据缓存的效果。

// Client_MuliThereadDlg.h : header file
//
#pragma once


struct RECVPARAM
{
	SOCKET sock;
	HWND hwnd;
};
struct a_buffer_size
{
	char* a_buffer;
	int size;
};
struct ALL_BUFFER  
{
	a_buffer_size ABUFFERSIZE[100];
	int bufferPos;

	ALL_BUFFER()
	{
		bufferPos = 0;
	}
};


// CClient_MuliThereadDlg dialog
class CClient_MuliThereadDlg : public CDialog
{
// Construction
public:
	CClient_MuliThereadDlg(CWnd* pParent = NULL);	// standard constructor

// Dialog Data
	enum { IDD = IDD_CLIENT_MULITHEREAD_DIALOG };

	protected:
	virtual void DoDataExchange(CDataExchange* pDX);	// DDX/DDV support


// Implementation
protected:
	HICON m_hIcon;

	// Generated message map functions
	virtual BOOL OnInitDialog();
	afx_msg void OnPaint();
	afx_msg HCURSOR OnQueryDragIcon();
	DECLARE_MESSAGE_MAP()
public:
	afx_msg void OnBnClickedOk();
public:
	BOOL InitSock(void);

private:
	SOCKET m_socket;

public:
	static DWORD WINAPI CClient_MuliThereadDlg::dataRecv(LPVOID IpParameter);
public:
	static DWORD WINAPI CClient_MuliThereadDlg::dataDisp(LPVOID IpParameter);
};

// Client_MuliThereadDlg.cpp : implementation file
//

#include "stdafx.h"
#include "Client_MuliTheread.h"
#include "Client_MuliThereadDlg.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif




// CClient_MuliThereadDlg dialog
//int maxBuffer = 10240000;
CRITICAL_SECTION g_cs;
ALL_BUFFER aBuffer;


CClient_MuliThereadDlg::CClient_MuliThereadDlg(CWnd* pParent /*=NULL*/)
	: CDialog(CClient_MuliThereadDlg::IDD, pParent)
{
	m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}

void CClient_MuliThereadDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
}

BEGIN_MESSAGE_MAP(CClient_MuliThereadDlg, CDialog)
	ON_WM_PAINT()
	ON_WM_QUERYDRAGICON()
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()


// CClient_MuliThereadDlg message handlers


BOOL CClient_MuliThereadDlg::OnInitDialog()
{
	CDialog::OnInitDialog();

	// Set the icon for this dialog.  The framework does this automatically
	//  when the application's main window is not a dialog
	SetIcon(m_hIcon, TRUE);			// Set big icon
	SetIcon(m_hIcon, FALSE);		// Set small icon

	// TODO: Add extra initialization here
	InitSock();
	RECVPARAM *pRecvParam1 = new RECVPARAM;
	RECVPARAM *pRecvParam2 = new RECVPARAM;
	pRecvParam1->sock =m_socket;
	pRecvParam1->hwnd =m_hWnd;
    pRecvParam2 = pRecvParam1;
	HANDLE mThread1 = CreateThread(NULL,0,dataRecv,(LPVOID)pRecvParam1,0,NULL);
	HANDLE mThread2 = CreateThread(NULL,0,dataDisp,(LPVOID)pRecvParam2,0,NULL);
	CloseHandle(mThread1);
	CloseHandle(mThread2);
	InitializeCriticalSection(&g_cs);
	return TRUE;  // return TRUE  unless you set the focus to a control
}

// If you add a minimize button to your dialog, you will need the code below
//  to draw the icon.  For MFC applications using the document/view model,
//  this is automatically done for you by the framework.

void CClient_MuliThereadDlg::OnPaint()
{
	if (IsIconic())
	{
		CPaintDC dc(this); // device context for painting

		SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0);

		// Center icon in client rectangle
		int cxIcon = GetSystemMetrics(SM_CXICON);
		int cyIcon = GetSystemMetrics(SM_CYICON);
		CRect rect;
		GetClientRect(&rect);
		int x = (rect.Width() - cxIcon + 1) / 2;
		int y = (rect.Height() - cyIcon + 1) / 2;

		// Draw the icon
		dc.DrawIcon(x, y, m_hIcon);
	}
	else
	{
		CDialog::OnPaint();
	}
}

// The system calls this function to obtain the cursor to display while the user drags
//  the minimized window.
HCURSOR CClient_MuliThereadDlg::OnQueryDragIcon()
{
	return static_cast<HCURSOR>(m_hIcon);
}


void CClient_MuliThereadDlg::OnBnClickedOk()
{
	// TODO: Add your control notification handler code here
	DeleteCriticalSection(&g_cs);
	OnOK();
}



BOOL CClient_MuliThereadDlg::InitSock(void)
{
	WSADATA wsaData;
	int iResult = WSAStartup( MAKEWORD(2,2), &wsaData );


	//SOCKET m_socket;
	m_socket = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP );


	sockaddr_in service;

	service.sin_family = AF_INET;
	service.sin_addr.s_addr = inet_addr("163.180.117.229");
	service.sin_port = htons( 6000 );
	if ( bind( m_socket, (SOCKADDR*) &service, sizeof(service) ) == SOCKET_ERROR ) {
		closesocket(m_socket);
		return FALSE;
	}
	listen( m_socket, SOMAXCONN );
	return TRUE;
}

DWORD WINAPI CClient_MuliThereadDlg::dataRecv(LPVOID IpParameter)
{
	SOCKET sock = ((RECVPARAM*)IpParameter)->sock;
	//HWND hwnd = ((RECVPARAM*)IpParameter)->hwnd;
	//HDC hdc = ::GetDC(hwnd);
	SOCKET AcceptSocket;


	SOCKADDR_IN serverInfo;
	int len = sizeof(SOCKADDR);

	AcceptSocket = accept(sock , (SOCKADDR*)&serverInfo, &len);


	int flag = 1;

	int PackteSize = 1024;
	int PacketCount,LastDataPacket;
	int lSzie;

	char* recvbuf;
	char* buffer_last;
	char* buffer;
	char recvbuf_count[10];
	char recvbuf_last[6];
	char temp[10];
	int pos;
	int bytesRecv,num;
	int bytesRecv_count,bytesRecv_last;

	

//	int test;
	int pos_temp;
	recvbuf = (char*)malloc(sizeof(char)*(PackteSize+10));

	while(1)
	{

		bytesRecv_count = recv(AcceptSocket,recvbuf_count,10,0);
		if ( bytesRecv_count == 0 )
			break;

		PacketCount = atoi(recvbuf_count);

		//receive the LastDataPacket
		bytesRecv_last = recv(AcceptSocket,recvbuf_last,6,0);

		LastDataPacket = atoi(recvbuf_last);

		lSzie = PackteSize * PacketCount + LastDataPacket;



		buffer_last = (char*)malloc(sizeof(char)*(LastDataPacket+10));


		buffer = (char*)malloc(sizeof(char)*lSzie);


		int iRecvSize;
		int iRet;
		int idx;

		int i;
		for (i=0;i<PacketCount;i++)
		{
			iRecvSize = PackteSize + 10;
			idx = 0;
			while (iRecvSize > 0)
			{
				iRet = recv(AcceptSocket, recvbuf+idx, iRecvSize, 0);
				if (iRet > 0)
				{
					idx += iRet;
					iRecvSize -= iRet;
				}
				else if (iRet == 0)
				{
					break;
				}
				else if ( iRet == SOCKET_ERROR)
				{
					break;
				}
			}

			memcpy(temp,recvbuf,10);
			pos = atoi(temp);

			memcpy(buffer+pos,recvbuf+10,PackteSize);
		}
		iRecvSize = LastDataPacket + 10;
		idx = 0;
		while (iRecvSize > 0)
		{
			iRet = recv(AcceptSocket, buffer_last+idx, iRecvSize, 0);
			if (iRet > 0)
			{
				idx += iRet;
				iRecvSize -= iRet;
			}
			else if (iRet == 0)
			{
				break;
			}
			else if ( iRet == SOCKET_ERROR)
			{
				break;
			}
		}

		memcpy(temp,buffer_last,10);
		pos = atoi(temp);
		memcpy(buffer+pos,buffer_last+10,LastDataPacket);

		EnterCriticalSection(&g_cs);
		pos_temp = aBuffer.bufferPos;
		aBuffer.ABUFFERSIZE[pos_temp].a_buffer = (char*)malloc(sizeof(char)*lSzie);
		memcpy(aBuffer.ABUFFERSIZE[pos_temp].a_buffer,buffer,lSzie);
		aBuffer.ABUFFERSIZE[pos_temp].size = lSzie;
		aBuffer.bufferPos++;
		LeaveCriticalSection(&g_cs);





		free(buffer_last);
		free(buffer);
	}


	free(recvbuf);
	
	


	closesocket(AcceptSocket);

	WSACleanup();

	
	return 0;
}

DWORD WINAPI CClient_MuliThereadDlg::dataDisp(LPVOID IpParameter)
{
	HWND hwnd = ((RECVPARAM*)IpParameter)->hwnd;
	HDC hdc = ::GetDC(hwnd);

	IPicture* pPic;
	IStream* pStm;

	int pos_temp;
	int lSzie;
	char* buffer;

	while(TRUE)
	{
		EnterCriticalSection(&g_cs);
		if (aBuffer.bufferPos > 0)
		{
			
			pos_temp = aBuffer.bufferPos;
			lSzie = aBuffer.ABUFFERSIZE[pos_temp-1].size;
			buffer = (char*)malloc(sizeof(char)*lSzie);
			memcpy(buffer,aBuffer.ABUFFERSIZE[pos_temp-1].a_buffer,lSzie);			
			aBuffer.bufferPos--;
			free(aBuffer.ABUFFERSIZE[pos_temp-1].a_buffer);

			LeaveCriticalSection(&g_cs);


			HGLOBAL hGlobal = GlobalAlloc(GMEM_MOVEABLE,lSzie);
			LPVOID pvData = NULL;
			pvData = GlobalLock(hGlobal);
			memcpy(pvData,buffer,lSzie);
			GlobalUnlock(hGlobal);
			CreateStreamOnHGlobal(hGlobal,TRUE,&pStm);
			ULARGE_INTEGER  pSeek;
			LARGE_INTEGER  dlibMove  ={0};
			pStm->Seek(dlibMove,STREAM_SEEK_SET,&pSeek);
			OleLoadPicture(pStm,lSzie,TRUE,IID_IPicture,(LPVOID*)&pPic);


			OLE_XSIZE_HIMETRIC hmWidth; 
			OLE_YSIZE_HIMETRIC hmHeight; 
			pPic->get_Width(&hmWidth);
			pPic->get_Height(&hmHeight);
			pPic->Render(hdc,0,0,320,240,0,hmHeight,hmWidth,-hmHeight,NULL);
			GlobalFree(hGlobal);
			free(buffer);
		}
		else
			LeaveCriticalSection(&g_cs);
	}

	//free(buffer);
	pPic->Release();
	pStm->Release();

	return 0;
}