当前位置:文档之家› 孙鑫16课--线程同步与异步套接字编程

孙鑫16课--线程同步与异步套接字编程

孙鑫16课--线程同步与异步套接字编程
孙鑫16课--线程同步与异步套接字编程

孙鑫16课:线程同步与异步套接字编程

利用事件对象实现线程同步:

事件对象(互斥对象也属于内核对象)也属于内核对象,包含一个使用计数,一个用于指明该事件是一个自动重置的事件还是一个人工重置的事件的布尔值,另一个用于指明该事件处于已通知状态还是未通知状态的布尔值。

有两种不同类型的事件对象。一种是人工重置的事件,另一种是自动重置的事件。当人工重置的事件得到通知时,等待该事件的所有线程均变为可调度线程。当一个自动重置的事件得到通知时,等待该事件的线程中只有一个线程变为可调度线程。

建立一个WIN32的控制台应用程序:

#include

#include

DWORD WINAPI Fun1Proc(

LPVOID lpParameter // thread data

);

DWORD WINAPI Fun2Proc(

LPVOID lpParameter // thread data

);

int tickets=100;

HANDLE g_hEvent;

void main()

{

HANDLE hThread1;

HANDLE hThread2;

hThread1=CreateThread(NULL,0,Fun1Proc,NULL,0,NULL);

hThread2=CreateThread(NULL,0,Fun2Proc,NULL,0,NULL);

CloseHandle(hThread1);

CloseHandle(hThread2);

//g_hEvent=CreateEvent(NULL,FALSE,FALSE,NULL);

g_hEvent=CreateEvent(NULL,FALSE,FALSE,"tickets");//自动重置,初始无信号。

if(g_hEvent)

{

if(ERROR_ALREADY_EXISTS==GetLastError())

{

cout<<"only instance can run!"<

return;

}

}

SetEvent(g_hEvent);

Sleep(4000);

CloseHandle(g_hEvent);

}

DWORD WINAPI Fun1Proc(

LPVOID lpParameter // thread data

)

{

while(TRUE)

{

WaitForSingleObject(g_hEvent,INFINITE);

// ResetEvent(g_hEvent);

if(tickets>0)

{

Sleep(1);

cout<<"thread1 sell ticket : "<

}

else

break;

SetEvent(g_hEvent);

}

return 0;

}

DWORD WINAPI Fun2Proc(

LPVOID lpParameter // thread data

)

{

while(TRUE)

{

WaitForSingleObject(g_hEvent,INFINITE);

// ResetEvent(g_hEvent);

if(tickets>0)

{

Sleep(1);

cout<<"thread2 sell ticket : "<

}

else

break;

SetEvent(g_hEvent);

}

return 0;

}

下面创建另一个线程同步的方式:关键代码段:

关键代码段(临界区)工作在用户方式下。

关键代码段(临界区)是指一个小代码段,在代码能够执行前,它必须独占对某些资源的访问权。

可以把访问同一种资源的代码看成是关键代码段。

新建一个WIN32的控制台程序:

#include

#include

DWORD WINAPI Fun1Proc(

LPVOID lpParameter // thread data

);

DWORD WINAPI Fun2Proc(

LPVOID lpParameter // thread data

);

int tickets=100;

CRITICAL_SECTION CriticalSection;

void main()

{

HANDLE hThread1;

HANDLE hThread2;

hThread1=CreateThread(NULL,0,Fun1Proc,NULL,0,NULL);

hThread2=CreateThread(NULL,0,Fun2Proc,NULL,0,NULL);

CloseHandle(hThread1);

CloseHandle(hThread2);

InitializeCriticalSection(&CriticalSection);

Sleep(4000);

DeleteCriticalSection(&CriticalSection);

}

DWORD WINAPI Fun1Proc(

LPVOID lpParameter // thread data

)

{

while(TRUE)

{

EnterCriticalSection(&CriticalSection); //在要保护的资源代码前加上这句,

//在访问后释放临界区对象所有权。如果得不到对临界资源的访问权,则线程等待

下去。

//线程1执行完成之后,线程1退出,但是如果线程1没有释放临界区对象的所有权,则线程2一直等待临界区对象的使用权,

//则线程2无法得到临界区对象的使用权,线程2一直等,直到主线程退出。进程退出,线程2也退出。

if(tickets>0)

{

Sleep(1);

cout<<"thread1 sell ticket : "<

}

else

break;

LeaveCriticalSection(&CriticalSection);

}

return 0;

}

DWORD WINAPI Fun2Proc(

LPVOID lpParameter // thread data

)

{

while(TRUE)

{

EnterCriticalSection(&CriticalSection);

if(tickets>0)

{

Sleep(1);

cout<<"thread2 sell ticket : "<

}

else

break;

LeaveCriticalSection(&CriticalSection);

}

return 0;

}

在使用临界区对象的时候,要注意释放临界区对象的所有权。

要注意死锁的问题。死锁问题:线程1拥有了临界区对象A,等待临界区对象B的拥有权,线程2拥有了临界区对象B,等待临界区对象A的拥有权,就造成了死锁。死锁代码如下:#include

#include

DWORD WINAPI Fun1Proc(

LPVOID lpParameter // thread data

);

DWORD WINAPI Fun2Proc(

LPVOID lpParameter // thread data

);

int tickets=100;

CRITICAL_SECTION g_csA;

CRITICAL_SECTION g_csB;

void main()

{

HANDLE hThread1;

HANDLE hThread2;

hThread1=CreateThread(NULL,0,Fun1Proc,NULL,0,NULL);

hThread2=CreateThread(NULL,0,Fun2Proc,NULL,0,NULL);

CloseHandle(hThread1);

CloseHandle(hThread2);

InitializeCriticalSection(&g_csA);

InitializeCriticalSection(&g_csB);

Sleep(4000);

DeleteCriticalSection(&g_csA);

DeleteCriticalSection(&g_csB);

}

DWORD WINAPI Fun1Proc(

LPVOID lpParameter // thread data

)

{

while(TRUE)

{

EnterCriticalSection(&g_csA);

Sleep(1);

EnterCriticalSection(&g_csB);

if(tickets>0)

{

Sleep(1);

cout<<"thread1 sell ticket : "<

}

else

break;

LeaveCriticalSection(&g_csB);

LeaveCriticalSection(&g_csA);

}

return 0;

}

DWORD WINAPI Fun2Proc(

LPVOID lpParameter // thread data

)

{

while(TRUE)

{

EnterCriticalSection(&g_csB);

Sleep(1);

EnterCriticalSection(&g_csA);

if(tickets>0)

{

Sleep(1);

cout<<"thread2 sell ticket : "<

}

else

break;

LeaveCriticalSection(&g_csA);//释放的顺序无所谓

LeaveCriticalSection(&g_csB);

}

cout<<"thread2 is running!"<

return 0;

}

三种实现线程同步的方式的比较:

互斥对象、事件对象与关键代码段的比较

?互斥对象和事件对象属于内核对象,利用内核对象进行线程同步,速度较慢,但利

用互斥对象和事件对象这样的内核对象,可以在多个进程中的各个线程间进行同步。

?关键代码段是工作在用户方式下,同步速度较快,但在使用关键代码段时,很容易

进入死锁状态,因为在等待进入关键代码段时无法设定超时值。

推荐书目

《Windows核心编程》机械工业出版社

在实现线程同步时,首选关键代码段。若在MFC程序中,可以在一个类的构造函数中调用InitializeCriticalSection();在析构函数中调用DeleteCriticalSection()。在要保护的代码前面加上EnterCriticalSection();在访问完要保护的资源后调用LeaveCriticalSection();记得一定要释

放关键代码段。如果构造了多个临界区对象,要注意线程死锁。多个进程的各个线程间,要用互斥对象和事件对象。

基于消息的异步套接字编程:

?Windows套接字在两种模式下执行I/O操作,阻塞和非阻塞。在阻塞模式下,在I/O

操作完成前,执行操作的Winsock函数会一直等待下去,不会立即返回程序(将控制权交还给程序)。而在非阻塞模式下,Winsock函数无论如何都会立即返回。

?Windows Sockets为了支持Windows消息驱动机制,使应用程序开发者能够方便地

处理网络通信,它对网络事件采用了基于消息的异步存取策略。

?Windows Sockets的异步选择函数WSAAsyncSelect()提供了消息机制的网络事件选

择,当使用它登记的网络事件发生时,Windows应用程序相应的窗口函数将收到一个消息,消息中指示了发生的网络事件,以及与事件相关的一些信息。

int WSAEnumProtocols( LPINT lpiProtocols,LPWSAPROTOCOL_INFO lpProtocolBuffer,ILPDWORD lpdwBufferLength);

?Win32平台支持多种不同的网络协议,采用Winsock2,就可以编写可直接使用任何

一种协议的网络应用程序了。通过WSAEnumProtocols函数可以获得系统中安装的网络协议的相关信息。

?lpiProtocols,一个以NULL结尾的协议标识号数组。这个参数是可选的,如果

lpiProtocols为NULL,则返回所有可用协议的信息,否则,只返回数组中列出的协议信息。

?lpProtocolBuffer,[out],一个用WSAPROTOCOL_INFO结构体填充的缓冲区。

WSAPROTOCOL_INFO结构体用来存放或得到一个指定协议的完整信息。

?lpdwBufferLength,[in, out],在输入时,指定传递给WSAEnumProtocols()函数的

lpProtocolBuffer缓冲区的长度;在输出时,存有获取所有请求信息需传递给WSAEnumProtocols ()函数的最小缓冲区长度。这个函数不能重复调用,传入的缓冲区必须足够大以便能存放所有的元素。这个规定降低了该函数的复杂度,并且由于一个机器上装载的协议数目往往是很少的,所以并不会产生问题。

下面采用异步套接字编写一个网络聊天室程序:

新建一个基于对话框的程序:

在BOOL CChatApp::InitInstance()中加入:

WORD wVersionRequested;

WSADATA wsaData;

int err;

wVersionRequested = MAKEWORD( 2, 2 );//最高版本

err = WSAStartup( wVersionRequested, &wsaData );

if ( err != 0 )

{

return FALSE;

}

if ( LOBYTE( wsaData.wVersion ) != 2 ||

HIBYTE( wsaData.wVersion ) != 2 )

WSACleanup( );

return FALSE;

}

在stdafx.h中加入:#include

再LINK Ws2_32.lib

给CChatApp增加一个析构函数,在此函数中终止对套接字库的使用:

CChatApp::~CChatApp()

{

WSACleanup( );

}

为CChatDlg增加private:

SOCKET m_socket;

在CChatDlg::CChatDlg中对套接字进行初始化。m_socket=0;

在析构函数中关闭套接字:

CChatDlg::~CChatDlg()

{

if (m_socket)

{

closesocket(m_socket);

}

}

在CChatDlg中增加BOOL CChatDlg::InitSocket()函数。函数代码如下:

BOOL CChatDlg::InitSocket()

{

m_socket=WSASocket(AF_INET,SOCK_DGRAM,0,NULL,0,0);

if (INV ALID_SOCKET ==m_socket)

{

MessageBox("创建套接字失败!");

return FALSE;

}

SOCKADDR_IN skaddr;

skaddr.sin_addr.S_un.S_addr=htonl(INADDR_ANY);

skaddr.sin_family=AF_INET;

skaddr.sin_port=htons(6000);

if(SOCKET_ERROR==bind(m_socket,(SOCKADDR*)&skaddr,sizeof(SOCKADDR_IN))) {

MessageBox("绑定失败!");

return FALSE;

}

if(SOCKET_ERROR==WSAAsyncSelect(m_socket,m_hWnd,UM_SOCK,FD_READ))//一旦有FD_READ事件发生,系统就会触发这个事件,

//系统就会通过UM_SOCK消息通知我们,在这个消息的响应函数中,接收数据就能收到数据。

MessageBox("注册网络读取事件失败!");

return FALSE;

}

return TRUE;

}

在BOOL CChatDlg::OnInitDialog()中加入

InitSocket();

在ChatDlg.h加入:

#define UM_SOCK WM_USER+1

afx_msg void OnSock(WPARAM wParam,LPARAM lParam);

在BEGIN_MESSAGE_MAP(CChatDlg, CDialog)中加上红色的那句

//{{AFX_MSG_MAP(CChatDlg)

ON_WM_SYSCOMMAND()

ON_WM_PAINT()

ON_WM_QUERYDRAGICON()

//}}AFX_MSG_MAP

ON_COMMAND(UM_SOCK,OnSock)

END_MESSAGE_MAP()

将接收编辑框的多行属性选上。

void CChatDlg::OnSock(WPARAM wParam,LPARAM lParam)

{

switch(LOWORD(lParam))

{

case FD_READ:

WSABUF wsabuf;

wsabuf.buf=new char[200];

wsabuf.len=200;

DWORD dwRead;

DWORD dwFlag=0;

SOCKADDR_IN addrFrom;

int len=sizeof(SOCKADDR);

CString str;

CString strTemp;

HOSTENT *pHost;

if(SOCKET_ERROR==WSARecvFrom(m_socket,&wsabuf,1,&dwRead,&dwFlag,

(SOCKADDR*)&addrFrom,&len,NULL,NULL))

{

MessageBox("接收数据失败!");

return;

}

pHost=gethostbyaddr((char*)&addrFrom.sin_addr.S_un.S_addr,4,AF_INET);

//str.Format("%s说:%s",inet_ntoa(addrFrom.sin_addr),wsabuf.buf);

str.Format("%s说:%s",pHost->h_name,wsabuf.buf);

str+="\r\n";

GetDlgItemText(IDC_EDIT_RECV,strTemp);

str+=strTemp;

SetDlgItemText(IDC_EDIT_RECV,str);

break;

}

}

void CChatDlg::OnBtnSend()

{

// TODO: Add your control notification handler code here

DWORD dwIP;

CString strSend;

WSABUF wsabuf;

DWORD dwSend;

int len;

CString strHostName;

SOCKADDR_IN addrTo;

HOSTENT* pHost;

if(GetDlgItemText(IDC_EDIT_HOSTNAME,strHostName),strHostName=="") {

((CIPAddressCtrl*)GetDlgItem(IDC_IPADDRESS1))->GetAddress(dwIP);

addrTo.sin_addr.S_un.S_addr=htonl(dwIP);

}

else

{

pHost=gethostbyname(strHostName);

addrTo.sin_addr.S_un.S_addr=*((DWORD*)pHost->h_addr_list[0]);

}

addrTo.sin_family=AF_INET;

addrTo.sin_port=htons(6000);

GetDlgItemText(IDC_EDIT_SEND,strSend);

len=strSend.GetLength();

wsabuf.buf=strSend.GetBuffer(len);

wsabuf.len=len+1;

SetDlgItemText(IDC_EDIT_SEND,"");

if(SOCKET_ERROR==WSASendTo(m_socket,&wsabuf,1,&dwSend,0,

(SOCKADDR*)&addrTo,sizeof(SOCKADDR),NULL,NULL)) {

MessageBox("发送数据失败!");

return;

} }

操作系统OS报告读者与写者问题(进程同步问题)

目录 一、课程设计目的及要求 (1) 二、相关知识 (1) 三、题目分析 (2) 四、概要设计 (4) 五、代码及流程 (5) 六、运行结果 (11) 七、设计心得 (12) 八、参考文献 (12)

一、课程设计目的及要求 读者与写者问题(进程同步问题) 用n 个线程来表示n个读者或写者。每个线程按相应测试数据文件的要求,进行读写操作。请用信号量机制分别实现读者优先和写者优先的读者-写者问题。 读者-写者问题的读写操作限制: 1)写-写互斥; 2)读-写互斥; 3)读-读允许; 写者优先的附加限制:如果一个读者申请进行读操作时已有另一写者在等待访问共享资源,则该读者必须等到没有写者处于等待状态后才能开始读操作。 二、相关知识 Windows API: 在本实验中涉及的API 有: 1线程控制: CreateThread 完成线程创建,在调用进程的地址空间上创建一个线程,以执行指定的函数;它的返回值为所创建线程的句柄。 HANDLE CreateThread( LPSECURITY_ATTRIBUTES lpThreadAttributes, // SD DWORD dwStackSize, // initial stack size LPTHREAD_START_ROUTINE lpStartAddress, // thread function LPVOID lpParameter, // thread argument DWORD dwCreationFlags, // creation option LPDWORD lpThreadId // thread identifier ); 2 ExitThread 用于结束当前线程。 VOID ExitThread( DWORD dwExitCode // exit code for this thread ); 3Sleep 可在指定的时间内挂起当前线程。 VOID Sleep( DWORD dwMilliseconds // sleep time ); 4信号量控制: WaitForSingleObject可在指定的时间内等待指定对象为可用状态; DWORD WaitForSingleObject( HANDLE hHandle, // handle to object DWORD dwMilliseconds // time-out interval );

java多线程试题答案

多线程 一.选择题 1.下列说法中错误地一项是() A.线程就是程序.线程是一个程序地单个执行流 B.多线程是指一个程序地多个执行流.多线程用于实现并发 2.下列哪个一个操作不能使线程从等待阻塞状态进入对象阻塞状态() A.等待阴塞状态下地线程被()唤 B.等待阻塞状态下地纯种被()中断 C.等待时间到 D.等待阻塞状态下地线程调用()方法 3.下列哪个方法可以使线程从运行状态进入其他阻塞状态() A. 4.下列说法中错误地一项是() A.一个线程是一个类地实例 B.线程从传递给纯种地实例()方法开始执行 C.线程操作地数据来自实例 D.新建地线程调用()方法就能立即进入运行状态 5.下列关于类提供地线程控制方法地说法中,错误地一项是() A.在线程中执行线程地()方法,则线程等待直到执行完成 B.线程通过调用()方法来中断其阻塞状态 C.若线程调用方法()返回值为,则说明正在执行中 D.()方法返回当前线程地引用 6.下列说法中,错误地一项是() A.对象锁在()语句执行完之后由持有它地线程返还 B.对象锁在()语句中出现异常时由持有它地线程返还 C.当持有锁地线程调用了该对象地()方法时,线程将释放其持有地锁 D.当持有锁地线程调用了该对象地构造方法时,线程将释放其持有地锁 7.下面地哪一个关键字通常用来对对象地加锁,从而使得对对象地访问是排他地 A. 二.填空题 . 在操作系统中,被称做轻型地进程是线程 . 多线程程序设计地含义是可以将一个程序任务分成几个并行地任务 . 在程序中,()方法地实现有两种方式:实现接口和继承类.多个线程并发执行时,各个线程中语句地执行顺序是确定地,但是线程之间地相对执行顺序是不确定地 中地对象锁是一种独占地排他锁 .程序中可能出现一种情况:多个线种互相等待对方持有地锁,而在得到对方地锁之前都不会释放自己地锁,这就是死锁b5E2R。 .线程地优先级是在类地常数和之间地一个值 .处于新建状态地线程可以使用地控制方法是()和(). .一个进程可以包含多个线程 三.简答题

操作系统 实验 五 线程间的互斥与同步

实验五线程间的互斥与同步 实验学时:2学时 实验类型:验证、设计型 一、实验目的 理解POSIX线程(Pthread)互斥锁和POSIX信号量机制,学习它们的使用方法;编写程序,实现多个POSIX线程的同步控制。 二,实验内容 创建4个POSIX线程。其中2个线程(A和B)分别从2个数据文件(data1.txt和data2.txt)读取10个整数. 线程A和B把从文件中读取的逐一整数放入一个缓冲池. 缓冲池由n个缓冲区构成(n=5,并可以方便地调整为其他值),每个缓冲区可以存放一个整数。另外2个线程,C和D,各从缓冲池读取10数据。线程C、D每读出2个数据,分别求出它们的和或乘积,并打印输出。 提示:在创建4个线程当中,A和B是生产者,负责从文件读取数据到公共的缓冲区,C和D是消费者,从缓冲区读取数据然后作不同的计算(加和乘运算)。使用互斥锁和信号量控制这些线程的同步。不限制线程C和D从缓冲区得到的数据来自哪个文件。 在开始设计和实现之前,务必认真阅读课本6.8.4节和第6章后面的编程项目——生产者-消费者问题。

三,实验要求 按照要求编写程序,放在相应的目录中,编译成功后执行,并按照要求分析执行结果,并写出实验报告。 四,实验设计 1,功能设计 根据实验要求,主程序需要创建四个线程,两个线程负责从文件读取数据到缓冲区,两个线程负责将缓冲区的数据做数学运算。由于同一个进程中的各个线程共享资源,可以用一个二维数组的全局变量作为公共缓冲区,同时还需要一个整形全局变量size用来做数组的索引。读线程的运行函数打开不同的文件并从中读取数据到二维数组中,每次写入数组后size加一。运算线程从二维数组中读数并做运算,每次读数之前size减一。本题的关键在于如何使用信号量保证进程的同步与互斥。在运算线程从缓冲区读取之前缓冲区里必须有数,即任意时刻运算操作的执行次数必须小于等于读取操作的执行次数。同时应该保证两个读线程和两个运算线程两两互斥。由于以上分析,使用了四个信号量sem1,sem2,sem3和sem4。sem1保证线程1和线程2互斥,sem2保证线程3和线程4互斥,sem3保证线程3和线程4互斥,sem4保证线程4和线程1互斥。即这四个信号量使四个线程循环进行,从而保证了运行结果的正确性。 源代码及注释: #include #include #include #define NUM 200

c task执行线程异步操作

c task执行线程异步操作 在C#4.0之前需要执行一个复杂的异步操作时,只能使用CLR线程池技术来执行一个任务。线程池执行异步任务时,不知道任务何时完成,以及任务的在任务完成后不能获取到返回值。但是在C#4.0中引人了一个的任务 (System.Threading.Tasks命名空间的类型)机制来解决异步操作完成时间和完成后返回值的问题。 1.使用Task类创建并执行简单任务 通过使用Task的构造函数来创建任务,并调用Start方法来启动任务并执行异步操作。创建任务时,必须传递一个Action或Action<Object>类型的委托回调方法,可以选择的传递任务执行时说需要的数据对象等。Task类的构造函数如下: public Task(Action action); public Task(Action<object> action, object state); public Task(Action action, CancellationToken cancellationToken); public Task(Action action, TaskCreationOptions creationOptions); public Task(Action<object> action, object state, CancellationToken cancellationToken);

public Task(Action<object> action, object state, TaskCreationOptions creationOptions); public Task(Action action, CancellationToken cancellationToken, TaskCreationOptions creationOptions); public Task(Action<object> action, object state, CancellationToken cancellationToken, TaskCreationOptions creationOptions); 示例代码: 1: static void Main(string[] args) 2: { 3: Console.WriteLine("主线程执行业务处理."); 4: //创建任务 5: Task task = new Task(() => { 6: Console.WriteLine("使用System.Threading.Tasks.Task执行异步操作."); 7: for (int i = 0; i < 10; i++) 8: { 9: Console.WriteLine(i); 10: }

OS中的进程线程同步机制

OS中的进程/线程同步机制 1 常用并发机制 1.1 信号量(Semaphore) 用于进程间传递信号的一个整数值,在信号上只可以进行三种操作,即初始化、递减和递增,这三种操作都是原子操作。递减操作用于阻塞一个进程,递增操作用于解除一个进程的阻塞。信号量也称为计数信号量或一般信号量 1.2 二元信号量(Binary Semaphore) 只取0值和1值的信号量。 1.3 互斥量(Mutex) 类似于二元信号量。关键在于为其加锁(设定值为0)的进程和为其解锁(设定值为1)的进程必须为同一个进程。 1.4 条件变量(Cond) 一种数据类型,用于阻塞进程或线程,直到特定的条件为真。 1.5 管程(Monitor) 一种编程语言结构,它在一个抽象数据类型中封装了变量、访问过程和初始化代码。管程的变量只能由管程自身的访问过程访问,每次只能有一个进程在其中执行,访问过程即临界区。管程可以有一个等待进程队列。 1.6 事件标志(Event Sign) 用作同步机制的一个内存字。应用程序代码可为标志中的每个位关联不同的事件。通过测试相关的一个或多个位,线程可以等待一个或多个事件。在全部所需位都被设定(AND)或至少一个位被设定(OR)之前,线程会一直被阻塞。 1.7 信箱/消息(Mailbox) 两个进程间交换信息的一种方法,也可用于同步。 1.8 自旋锁(Spin Lock) 一种互斥机制,进程在一个无条件循环中执行,等待锁变量的值可用。

2 常用进程/线程同步机制介绍 2.1 Windows OS中常用进程/线程同步机制 2.1.1 临界区(Critical Section) 可用于进程和线程同步。 保证在某一时刻只有一个线程能访问数据的简便办法。在任意时刻只允许一个线程对共享资源进行访问。如果有多个线程试图同时访问临界区,那么在有一个线程进入后其他所有试图访问此临界区的线程将被挂起,并一直持续到进入临界区的线程离开。临界区在被释放后,其他线程可以继续抢占,并以此达到用原子方式操作共享资源的目的。 临界区包含两个操作原语: EnterCriticalSection()进入临界区 LeaveCriticalSection()离开临界区 EnterCriticalSection()语句执行后代码将进入临界区以后无论发生什么,必须确保与之匹配的LeaveCriticalSection()都能够被执行到。否则临界区保护的共享资源将永远不会被释放。虽然临界区同步速度很快,但却只能用来同步本进程内的线程,而不可用来同步多个进程中的线程。 MFC提供了很多功能完备的类,我用MFC实现了临界区。MFC为临界区提供有一个CCriticalSection类,使用该类进行线程同步处理是非常简单的。只需在线程函数中用CCriticalSection类成员函数Lock()和UnLock()标定出被保护代码片段即可。Lock()后代码用到的资源自动被视为临界区内的资源被保护。UnLock后别的线程才能访问这些资源。 2.1.2 互斥量(Mutex) 进程和线程都可用的一种同步机制。互斥量跟临界区很相似,只有拥有互斥对象的线程才具有访问资源的权限,由于互斥对象只有一个,因此就决定了任何情况下此共享资源都不会同时被多个线程所访问。当前占据资源的线程在任务处理完后应将拥有的互斥对象交出,以便其他线程在获得后得以访问资源。互斥量比临界区复杂。因为使用互斥不仅仅能够在同一应用程序不同线程中实现资源的安全共享,而且可以在不同应用程序的线程之间实现对资源的安全共享。 互斥量包含的几个操作原语: CreateMutex()创建一个互斥量 OpenMutex()打开一个互斥量 ReleaseMutex()释放互斥量 WaitForMultipleObjects()等待互斥量对象 2.1.3 信号量(Semaphore) 进程和线程都可用的同步机制。 信号量对象对线程的同步方式与前面几种方法不同,信号允许多个线程同时使用共享资源,这与操作系统中的PV操作相同。它指出了同时访问共享资源的线程最大数目。它允许多个线程在同一时刻访问同一资源,但是需要限制在同一

用多线程同步方法解决生产者-消费者问题(操作系统课设)

. 题目用多线程同步方法解决生产者-消费 者问题(Producer-Consumer Problem) 学院计算机科学与技术学院 专业软件工程 班级 姓名 指导教师 年月日

目录 目录 (1) 课程设计任务书 (2) 正文 (2) 1.设计目的与要求 (2) 1.1设计目的 (2) 1.2设计要求 (2) 2.设计思想及系统平台 (2) 2.1设计思想 (2) 2.2系统平台及使用语言 (2) 3.详细算法描述 (3) 4.源程序清单 (5) 5.运行结果与运行情况 (10) 6.调试过程 (15) 7.总结 (15) 本科生课程设计成绩评定表 (16)

课程设计任务书 学生姓名:专业班级: 指导教师:工作单位:计算机科学与技术学院 题目: 用多线程同步方法解决生产者-消费者问题 (Producer-Consumer Problem) 初始条件: 1.操作系统:Linux 2.程序设计语言:C语言 3.有界缓冲区内设有20个存储单元,其初值为0。放入/取出的数据项按增序设定为1-20这20个整型数。 要求完成的主要任务:(包括课程设计工作量及其技术要求,以及说明书撰写等具体要 求) 1.技术要求: 1)为每个生产者/消费者产生一个线程,设计正确的同步算法 2)每个生产者和消费者对有界缓冲区进行操作后,即时显示有界缓冲区的当前全部内容、当前指针位置和生产者/消费者线程的自定义标识符。 3)生产者和消费者各有两个以上。 4)多个生产者或多个消费者之间须共享对缓冲区进行操作的函数代码。 2.设计说明书内容要求: 1)设计题目与要求 2)总的设计思想及系统平台、语言、工具等。 3)数据结构与模块说明(功能与流程图) 4)给出用户名、源程序名、目标程序名和源程序及其运行结果。(要注明存储各个程序及其运行结果的主机IP地址和目录。) 5)运行结果与运行情况 (提示: (1)有界缓冲区可用数组实现。 (2)编译命令可用:cc -lpthread -o 目标文件名源文件名 (3)多线程编程方法参见附件。) 3. 调试报告: 1)调试记录 2)自我评析和总结 上机时间安排: 18周一~ 五 08:0 - 12:00 指导教师签名:年月日

操作系统课程设计用多进程同步方法解决生产者-消费者问题

操作系统课程设计 用多进程同步方法解决生产者-消费者问题 系别:计科系 专业: 计算机科学与技术 班级:04 级 4 班 学号:0410******* 姓名:苏德洪 时间:2006-7-7—2006-7-14

目录 一、题目: (3) 二、设计目的: (3) 三、总体设计思想概述: (3) 四、说明: (3) 五、设计要求: (3) 六、设计方案: (3) 七、流程图: (5) 八、运行结果 (7) 九、源程序 (11) 十、总结 (18) 十一、参考文献 (20)

一、题目: 用多进程同步方法解决生产者-消费者问题。 二、设计目的: 通过研究Linux 的进程机制和信号量实现生产者消费者问题的并发控制。 三、总体设计思想概述: 1、生产者—消费者问题是一种同步问题的抽象描述。 2、计算机系统中的每个进程都可以消费或生产某类资源。当系统中某一进程使用某一 资源时,可以看作是消耗,且该进程称为消费者。 3、而当某个进程释放资源时,则它就相当一个生产者。 四、说明: 有界缓冲区内设有20个存储单元,放入/取出的数据项设定为1-20这20个整型数。 五、设计要求: 1、每个生产者和消费者对有界缓冲区进行操作后,即时显示有界缓冲区的全部内容,当前 指针位置和生产者/消费者线程的标识符。 2、生产者和消费者各有两个以上。 3、多个生产者或多个消费者之间须有共享对缓冲区进行操作的函数代码。 六、设计方案: 通过一个有界缓冲区(用数组来实现,类似循环队列)把生产者和消费者联系起来。假定生产者和消费者的优先级是相同的,只要缓冲区未满,生产者就可以生产产品并将产品送入缓冲区。类似地,只要缓冲区未空,消费者就可以从缓冲区中去走产品并消费它。 应该禁止生产者向满的缓冲区送入产品,同时也应该禁止消费者从空的缓冲区中取出产品,这一机制有生产者线程和消费者线程之间的互斥关系来实现。 为解决生产者/消费者问题,应该设置两个资源信号量,其中一个表示空缓冲区的数目,用g_hFullSemaphore表示,其初始值为有界缓冲区的大小SIZE_OF_BUFFER;另一个表示缓冲区中产品的数目,用g_hEmptySemaphore表示,其初始值为0。另外,由于有界缓冲区是一个临界资源,必须互斥使用,所以还需要再设置一个互斥信号量g_hMutex,起初值为1。

4:一个经典的多线程同步问题汇总

一个经典的多线程同步问题 程序描述: 主线程启动10个子线程并将表示子线程序号的变量地址作为参数传递给子线程。子线程接收参数 -> sleep(50) -> 全局变量++ -> sleep(0) -> 输出参数和全局变量。 要求: 1.子线程输出的线程序号不能重复。 2.全局变量的输出必须递增。 下面画了个简单的示意图: 分析下这个问题的考察点,主要考察点有二个: 1.主线程创建子线程并传入一个指向变量地址的指针作参数,由于线程启动须要花费一定的时间,所以在子线程根据这个指针访问并保存数据前,主线程应等待子线程保存完毕后才能改动该参数并启动下一个线程。这涉及到主线程与子线程之间的同步。 2.子线程之间会互斥的改动和输出全局变量。要求全局变量的输出必须递增。这涉及到各子线程间的互斥。 下面列出这个程序的基本框架,可以在此代码基础上进行修改和验证。 //经典线程同步互斥问题 #include #include #include long g_nNum; //全局资源 unsigned int__stdcall Fun(void *pPM); //线程函数 const int THREAD_NUM = 10; //子线程个数 int main() { g_nNum = 0;

HANDLE handle[THREAD_NUM]; int i = 0; while (i < THREAD_NUM) { handle[i] = (HANDLE)_beginthreadex(NULL, 0, Fun, &i, 0, NULL); i++;//等子线程接收到参数时主线程可能改变了这个i的值} //保证子线程已全部运行结束 WaitForMultipleObjects(THREAD_NUM, handle, TRUE, INFINITE); return 0; } unsigned int__stdcall Fun(void *pPM) { //由于创建线程是要一定的开销的,所以新线程并不能第一时间执行到这来int nThreadNum = *(int *)pPM; //子线程获取参数 Sleep(50);//some work should to do g_nNum++; //处理全局资源 Sleep(0);//some work should to do printf("线程编号为%d 全局资源值为%d\n", nThreadNum, g_nNum); return 0; } 运行结果:

南昌大学操作系统线程进程同步实验报告

南昌大学实验报告 ---(1)进程/线程同步 学生姓名:学号:专业班级:网络工程131班 实验类型:■验证□综合□设计□创新实验日期:实验成绩: 一、实验目的 本实验讨论临界区问题及其解决方案。首先创建两个共享数据资源的并发线程。在没有同步控制机制的情况下,我们将看到某些异常现象。针对观察到的现象,本实验采用Windows 的信号量机制解决临界区互斥访问。 二、实验内容 2.1 进程/线程并发执行 Windows操作系统支持抢先式调度,这意味着一线程运行一段时间后,操作系统会暂停其运行并启动另一线程。也就是说,进程内的所有线程会以不可预知的步调并发执行。为了制造混乱,我们首先创建两个线程t1和t2。父线程(主线程)定义两个全局变量,比如accnt1和accnt2。每个变量表示一个银行账户,其值表示该账户的存款余额,初始值为0。线程模拟在两个账户之间进行转账的交易。也即,每个线程首先读取两个账户的余额,然后产生一个随机数r,在其中一个账户上减去该数,在另一个账户上加上该数。线程操作的代码框架如下: counter=0; do { tmp1 = accnt1 ; tmp2 = accnt2 ; r = rand ( ) ; accnt1 = tmp1 + r ; accnt2 = tmp2 ? r ; counter++; } while ( accnt1 + accnt2 == 0 ) ; print ( counter ) ; 两个线程执行相同的代码。只要它们的执行过程不相互交叉,那么两个账户的余额之和将永远是0。但如果发生了交叉,那么某线程就有可能读到新的accnt1值和老的accnt2值,从而导致账户余额数据发生混乱。线程一旦检测到混乱的发生,便终止循环并打印交易的次数(counter)。 请编写出完整的程序代码并运行,然后观察产生混乱需要的时间长短。因为这是我们编写的第一个程序,因此这里我给出了完整的代码,请参考。有能力的同学在参考下面的代码之前,请先自己尝试一下。 #include "stdafx.h" #include

Windows下多线程同步机制

多线程同步机制 Critical section(临界区)用来实现“排他性占有”。适用范围是单一进程的各线程之间。它是: ·一个局部性对象,不是一个核心对象。 ·快速而有效率。 ·不能够同时有一个以上的critical section被等待。 ·无法侦测是否已被某个线程放弃。 Mutex Mutex是一个核心对象,可以在不同的线程之间实现“排他性占有”,甚至几十那些现成分属不同进程。它是: ·一个核心对象。 ·如果拥有mutex的那个线程结束,则会产生一个“abandoned”错误信息。 ·可以使用Wait…()等待一个mutex。 ·可以具名,因此可以被其他进程开启。 ·只能被拥有它的那个线程释放(released)。 Semaphore Semaphore被用来追踪有限的资源。它是: ·一个核心对象。 ·没有拥有者。 ·可以具名,因此可以被其他进程开启。 ·可以被任何一个线程释放(released)。 Ev ent Object Ev ent object通常使用于overlapped I/O,或用来设计某些自定义的同步对象。它是: ·一个核心对象。 ·完全在程序掌控之下。 ·适用于设计新的同步对象。 · “要求苏醒”的请求并不会被储存起来,可能会遗失掉。 ·可以具名,因此可以被其他进程开启。 Interlocked Variable 如果Interlocked…()函数被使用于所谓的spin-lock,那么他们只是一种同步机制。所谓spin-lock是一种busy loop,被预期在极短时间内执行,所以有最小的额外负担(overhead)。系统核心偶尔会使用他们。除此之外,interlocked variables主要用于引用技术。他们:·允许对4字节的数值有些基本的同步操作,不需动用到critical section或mutex之类。 ·在SMP(Symmetric Multi-Processors)操作系统中亦可有效运作。 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

四种进程或线程同步互斥的控制方法

四种进程或线程同步互斥的控制方法 1、临界区:通过对多线程的串行化来访问公共资源或一段代码,速度快,适合控制数据访问。 2、互斥量:为协调共同对一个共享资源的单独访问而设计的。 3、信号量:为控制一个具有有限数量用户资源而设计。 4、事件:用来通知线程有一些事件已发生,从而启动后继任务的开始。 一临界区 临界区的使用在线程同步中应该算是比较简单,说它简单还是说它同后面讲到的其它方法相比更容易理解。举个简单的例子:比如说有一个全局变量(公共资源)两个线程都会对它进行写操作和读操作,如果我们在这里不加以控制,会产生意想不到的结果。假设线程A 正在把全局变量加1然后打印在屏幕上,但是这时切换到线程B,线程B又把全局变量加1然后又切换到线程A,这时候线程A打印的结果就不是程序想要的结果,也就产生了错误。解决的办法就是设置一个区域,让线程A在操纵全局变量的时候进行加锁,线程B如果想操纵这个全局变量就要等待线程A释放这个锁,这个也就是临界区的概念。 二互斥体 windows api中提供了一个互斥体,功能上要比临界区强大。也许你要问,这个东东和临界区有什么区别,为什么强大?它们有以下几点不一致: 1.critical section是局部对象,而mutex是核心对象。因此像waitforsingleobject是不可以等待临界区的。 2.critical section是快速高效的,而mutex同其相比要慢很多 3.critical section使用围是单一进程中的各个线程,而mutex由于可以有一个名字,因此它是可以应用于不同的进程,当然也可以应用于同一个进程中的不同线程。 4.critical section 无法检测到是否被某一个线程释放,而mutex在某一个线程结束之后会产生一个abandoned的信息。同时mutex只能被拥有它的线程释放。下面举两个应用mutex 的例子,一个是程序只能运行一个实例,也就是说同一个程序如果已经运行了,就不能再运行了;另一个是关于非常经典的哲学家吃饭问题的例子。 三事件 事件对象的特点是它可以应用在重叠I/O(overlapped I/0)上,比如说socket编程中有两种模型,一种是重叠I/0,一种是完成端口都是可以使用事件同步。它也是核心对象,因此可以被waitforsingleobje这些函数等待;事件可以有名字,因此可以被其他进程开启。 四信号量 semaphore的概念理解起来可能要比mutex还难,我先简单说一下创建信号量的函数,因为我在开始使用的时候没有很快弄清楚,可能现在还有理解不对的地方,如果有错误还是请大侠多多指教。 CreateSemaphore( LPSECURITY_ATTRIBUTES lpSemaphoreAttributes, // SD LONG lInitialCount, // initial count LONG lMaximumCount, // maximum count LPCTSTR lpName // object name )

实现异步串口

异步传输是一种典型的基于字节的输入输出,指数据按每次一个字节进行传输,其传输速度低。同步传输是把数据字节组合起来一起发送,这种组合称之为帧,其传输速度比异步传输快,同步串口的传送速率高,异步串口实现简单,这是异步串口与同步串口间最主要的区别。 一,异步非阻塞串口通讯的优点 读写串行口时,既可以同步执行,也可以重叠(异步)执行。 在同步执行时,函数直到操作完成后才返回。这意味着在同步执行时线程会被阻塞,从而导致效率下降。 在重叠执行时,即使操作还未完成,调用的函数也会立即返回。费时的I/O操作在后台进行,这样线程就可以干别的事情。 例如,线程可以在不同的句柄上同时执行I/O操作,甚至可以在同一句柄上同时进行读写操作。"重叠"一词的含义就在于此。 二,异步非阻塞串口通讯的基本原理 首先,确定要打开的串口名、波特率、奇偶校验方式、数据位、停止位,传递给CreateFile()函数打开特定串口; 其次,为了保护系统对串口的初始设置,调用 GetCommTimeouts()得到串口的原始超时设置; 然后,初始化DCB对象,调用SetCommState() 设置DCB,调用SetCommTimeouts()设置串口超时控制; 再次,调用SetupComm()设置串口接收发送数据的缓冲区大小,串口的设置就基本完成,之后就可以启动读写线程了。 三,异步非阻塞串口通讯的基础知识 VC串口通信技术网下面来介绍并举例说明一下编写异步非阻塞串口通讯的程序 中将会使用到的几个关键函数 CreateFile() 功能:打开串口设备 函数原型 1.HANDLE CreateFile( 2.LPCTSTR lpFileName, // 串口名称字符串;如: "COM1" 或 "COM2" 3.DWORD dwDesiredAccess, // 设置读写属性(访问模式);一般为 GENERIC_READ|GENERIC_WRITE, 4.DWORD dwShareMode, // 共享模式;"必须"为 0, 即不能共享 5.LPSECURITY_ATTRIBUTES lpSecurityAttributes, // 安全属性;一般为 NULL 6.DWORD dwCreationDistribution, // 创建方式,串口设置必须设置此值; 在这里"必须"为 OPEN_EXISTING 7.DWORD dwFlagsAndAttributes, // 文件属性和标志;在这里我们设置成 FILE_FLAG_OVERLAPPED ,实现异步I/O 8.HANDLE hTemplateFile // 临时文件的句柄,通常为NULL

用多线程同步方法解决生产者-消费者问题(操作系统课设)

用多线程同步方法解决生产者-消费者问题(操作系统课设)

题目 用多线程同步方法解决生产者-消费 者问题(Producer-Consume r Problem) 学院 物理学与电子信息工程学院 专业电子信息工程班级08电信本一班姓名 指导教师 2010 年12 月日

目录 目录 0 课程设计任务书 (1) 正文 (3) 1.设计目的与要求 (3) 1.1设计目的 (3) 1.2设计要求 (3) 2.设计思想及系统平台 (3) 2.1设计思想 (3) 2.2系统平台及使用语言 (3) 3.详细算法描述 (4) 4.源程序清单 (7) 5.运行结果与运行情况 (12) 6.调试过程 (16) 7.总结 (16)

课程设计任务书 题目: 用多线程同步方法解决生产者-消费者问题 (Producer-Consumer Problem) 初始条件: 1.操作系统:Linux 2.程序设计语言:C语言 3.有界缓冲区内设有20个存储单元,其初 值为0。放入/取出的数据项按增序设定为 1-20这20个整型数。 要求完成的主要任务:(包括课程设计工作量及其技术要求,以及说明书撰写等具体要求) 1.技术要求: 1)为每个生产者/消费者产生一个线程,设计正确的同步算法 2)每个生产者和消费者对有界缓冲区进行操作后,即时显示有界缓冲区的当前全部 内容、当前指针位置和生产者/消费者

线程的自定义标识符。 3)生产者和消费者各有两个以上。 4)多个生产者或多个消费者之间须共享对缓冲区进行操作的函数代码。 2.设计说明书内容要求: 1)设计题目与要求 2)总的设计思想及系统平台、语言、工具 等。 3)数据结构与模块说明(功能与流程图) 4)给出用户名、源程序名、目标程序名和源程序及其运行结果。(要注明存储各个 程序及其运行结果的主机IP地址和目 录。) 5)运行结果与运行情况 (提示: (1)有界缓冲区可用数组实现。 (2)编译命令可用:cc -lpthread -o 目标文件名源文件名 (3)多线程编程方法参见附件。) 3. 调试报告: 1)调试记录 2)自我评析和总结

操作系统第二章进程和线程复习题

第二章练习题 一、单项选择题 1.某进程在运行过程中需要等待从磁盘上读入数据,此时该进程的状态将( C )。 A. 从就绪变为运行; B.从运行变为就绪; C.从运行变为阻塞; D.从阻塞变为就绪2.进程控制块是描述进程状态和特性的数据结构,一个进程( D )。 A.可以有多个进程控制块; B.可以和其他进程共用一个进程控制块; C.可以没有进程控制块; D.只能有惟一的进程控制块。 3.临界区是指并发进程中访问共享变量的(D)段。 A、管理信息 B、信息存储 C、数据 D、 程序 4. 当__ B__时,进程从执行状态转变为就绪状态。 A. 进程被调度程序选中 B. 时间片到 C. 等待某一事件 D. 等待的事件发生 5. 信箱通信是一种( B )通信方式。 A. 直接通信 B. 高级通信

C. 低级通信 D. 信号量 6. 原语是(B)。 A、一条机器指令 B、若干条机器指令组成 C、一条特定指令 D、中途能打断的指令 7. 进程和程序的一个本质区别是(A)。 A.前者为动态的,后者为静态的; B.前者存储在内存,后者存储在外存; C.前者在一个文件中,后者在多个文件中; D.前者分时使用CPU,后者独占CPU。 8. 任何两个并发进程之间存在着(D)的关系。 A.各自完全独立B.拥有共享变量 C.必须互斥D.可能相互制约 9. 进程从运行态变为等待态可能由于(B )。 A.执行了V操作 B.执行了P 操作 C.时间片用完 D.有高优先级进程就绪 10. 用PV操作管理互斥使用的资源时,信号量的初值应定义为(B)。 A.任意整数 B.1 C.0 D.-1

多线程同步方法及比较

多线程同步方法及比较 多线程同步方法: 1.临界区:通过对多线程的串行化来访问公共资源或一段代码,速度快,适合控制数 据访问。. 2.互斥量:为协调一起对一个共享资源的单独访问而设计的。. 3.信号量:为控制一个具备有限数量用户资源而设计。. 4.事件:用来通知线程有一些事件已发生,从而启动后继任务的开始。 临界区(Critical Section).. 确保在某一时刻只有一个线程能访问数据的简便办法。在任意时刻只允许一个线程对共享资源进行访问。假如有多个线程试图同时访问临界区,那么在有一个线程进入后其他任何试图访问此临界区的线程将被挂起,并一直持续到进入临界区的线程离开。临界区在被释放后,其他线程能够继续抢占,并以此达到用原子方式操作共享资源的目的。 临界区包含两个操作原语: EnterCriticalSection()进入临界区 LeaveCriticalSection()离开临界区。 EnterCriticalSection()语句执行后代码将进入临界区以后无论发生什么,必须确保和之匹配的LeaveCriticalSection()都能够被执行到。否则临界区保护的共享资源将永远不会被释放。虽然临界区同步速度很快,但却只能用来同步本进程内的线程,而不可用来同步多个进程中的线程。 MFC为临界区提供有一个CCriticalSection类,使用该类进行线程同步处理是很简单的。只需在线程函数中用CCriticalSection类成员函数Lock()和UnLock()标定出被保护代码片段即可。Lock()后代码用到的资源自动被视为临界区内的资源被保护。UnLock后别的线程才能访问这些资源。. ------------------------------------------------

操作系统实验线程同步

实验2:线程同步 一、实验目的 (1)掌握Windows2000环境下,线程同步。 (2)熟悉Windows2000提供的线程同步与互斥API。 (3)用Windows2000提供的线程同步与互斥API解决实际问题 (producer-consumer)。 二、实验内容 生产者与消费者问题的实现。在Windows 2000环境下,创建一组“生产者”线程和一组“消费者”线程,并建立一个长度为N的全局数组作为共享缓冲区。“生产者”向缓冲区输入数据,“消费者”从缓冲区读出数据。当缓冲区满时,“生产者”必须阻塞,等待“消费者”取走缓冲区数据后将其唤醒。当缓冲区空时,“消费者”阻塞,等待“生产者”生产了产品后将其唤醒。试用信号量实现“生产者”与“消费者”线程之间的同步。 三、实验环境 (1)使用的操作系统及版本。 Windows xp professional (2)使用的编译系统及版本。 Visual c++ 6.0 四、实验步骤 1.等待一个对象(相当于p操作) WaitForSingleObject用于等待一个对象。它等待的对象可以为: Change notification:变化通知。 Console input:控制台输入。 Event:事件。 Job:作业。 Mutex:互斥信号量。 Process:进程。 Semaphore:计数信号量。

Thread:线程。 Waitable timer:定时器。 返回值: 如果成功返回,其返回值说明是何种事件导致函数返回。 访问描述 WAIT_ABANDONED 等待的对象是一个互斥(mutex)对象,该互斥对 象没有被拥有它的线程释放,它被设置为不能被唤 醒。 WAIT_OBJECT_0 指定对象被唤醒。 WAIT_TIMEOUT 超时。 2.创建信号量 CreateSemaphore用于创建一个信号量。 返回值: 信号量创建成功,将返回该信号量的句柄。如果给出的信号量名是系统已经存在的信号量,将返回这个已存在信号量的句柄。如果失败,系统返回NULL,可以调用函数GetLastError查询失败的原因。 3.打开信号量 OpenSemaphore用于打开一个信号量。 返回值: 信号量打开成功,将返回该信号量的句柄。如果失败,系统返回NULL,可以调用函数GetLastError查询失败的原因。 4.增加信号量的值 ReleaseSemaphore用于增加信号量的值。 返回值: 如果成功,将返回一个非0值。如果失败,系统返回0,可以调用函数GetLastError 查询失败的原因。 方法一: 程序代码: #include #include

异步调用机制及实现方法

这篇文章将介绍异步调用的实现机制及如何调用异步方法。大多数.NET开发者在经过delegate、Thread、AsynchronousInvocation之后,通常都会对以上概念产生混淆及误用。实际上,以上概念是.NET2.0版本中对并行编程的核心支持,基于概念上的错误认识有可能导致在实际的编程中,无法利用异步调用的特性优化我们的程序,例如大数据量加载引起的窗体”假死”。事实上这并不是一个困难的问题,该文将以一种逐层深入、抽丝剥茧的方式逐渐深入到异步编程的学习中。 同步与异步 大多数人并不喜欢阅读大量的文字说明,而喜欢直接阅读代码,因此,我们在下文中将主要以代码的形式阐述同步与异步的调用。 同步方法调用 假设我们有一个函数,它的功能是将当前线程挂起3秒钟。 static void Sleep() { Thread.Sleep(3000); } 通常,当你的程序在调用Sleep后,它将等待3秒钟的时间,在这3秒钟时间内,你不能做任何其他操作。3秒之后,控制权被交回给调用线程(通常也就是你的主线程,即WinForm程序的UI线程)。这种类型的调用称为同步,本次调用顺序如下: ● 调用Sleep(); ● Sleep()执行中; ● Sleep()执行完毕,控制权归还调用线程。 我们再次调用Sleep()函数,不同的是,我们要基于委托来完成这次调用。一般为了将函数绑定在委托中,我们要定义与函数返回类型、参数值完全一致的委托,这稍有点麻烦。但.NET内部已经为我们定义好了一些委托,例如MethodInvoker,这是一种无返回值、无参数的委托签名,这相当于你自定义了一种委托: public delegate void SimpleHandler(); 执行以下代码: MethodInvoker invoker = new MethodInvoker(Sleep); invoker.Invoke(); 我们使用了委托,但依然是同步的方式。主线程仍然要等待3秒的挂起,然后得到响应。 注意:Delegate.Invoke是同步方式的。

用多线程同步方法解决生产者-消费者问题

目录 1.需求分析 (1) 1.1 课程设计题目 (1) 1.2 课程设计任务 (1) 1.3 课程设计原理 (1) 1.4 课程设计要求 (1) 1.5 实验环境 (1) 2. 概要设计 (2) 2.1 课程设计方案概述 (2) 2.2 课程设计流程图 (2) 3.详细设计 (3) 3.1 主程序模块 (3) 3.2 生产者程序模块 (4) 3.3 消费者程序模块 (5) 4.调试中遇到的问题及解决方案 (5) 5.运行结果 (6) 6.实验小结 (7) 参考文献 (7) 附录:源程序清单 (7)

1.需求分析 1.1 课程设计题目 用多线程同步方法解决生产者-消费者问题 1.2 课程设计任务 (1)每个生产者和消费者对有界缓冲区进行操作后,即时显示有界缓冲区的全部内容、 当前指针位置和生产者/消费者线程的标识符。 (2)生产者和消费者各有两个以上。 (3)多个生产者或多个消费者之间须共享对缓冲区进行操作的函数代码。 1.3 课程设计原理 生产者和消费者问题是从操作系统中的许多实际同步问题中抽象出来的具有代表性的问题,它反映了操作系统中典型的同步例子,生产者进程(进程由多个线程组成)生产信息,消费者进程使用信息,由于生产者和消费者彼此独立,且运行速度不确定,所以很可能出现生产者已产生了信息而消费者却没有来得及接受信息这种情况。为此,需要引入由一个或者若干个存储单元组成的临时存储区(即缓冲区),以便存放生产者所产生的信息,解决平滑进程间由于速度不确定所带来的问题。 1.4 课程设计要求 (1)有界缓冲区内设有20个存储单元,放入/取出的数据项设定为1~20这20个整型数。 (2)每个生产者和消费者对有界缓冲区进行操作后,即时显示有界缓冲区的全部内容、 当前指针位置和生产者/消费者线程的标识符。 (3)生产者和消费者各有两个以上。 (4)多个生产者或多个消费者之间须共享对缓冲区进行操作的函数代码。 1.5 实验环境 系统平台:LINUX 开发语言:C 开发工具:PC机一台

相关主题
相关文档 最新文档