文档库

最新最全的文档下载
当前位置:文档库 > Sleep函数在线程同步中的作用

Sleep函数在线程同步中的作用

许多资料讲到线程的同步都会提到使用同步对象,等待函数,互锁函数等等,很少具体阐述Sleep函数在线程同步的作用。但很多多线程编程都会用到Sleep函数,与同步对象,等待函数,互锁函数配合使用,这是什么缘故?看了许多关于Sleep的介绍,但还是不懂它在线程同步中的具体作用。

把一个线程挂起指定时间

将线程挂起,其他线程有机会运行

Sleep没有任何线程同步的作用。

Sleep就是把自己挂起,结束当前时间片。

下面是一个两个线程排序的小程序,大家能否以它为例,讲一下其中Sleep()的作用。看过一些关于windows编程的书后,我觉得没有Sleep也可以,有互斥量和等待函数搭配的很好阿。求解释。

#include

#include

#include

#include

#include

using namespace std;

const int m=10;

int count=0,count1=0;

int r1[m],r2[m];

void bubblesort (int *r1, int ); //冒泡排序

void quicksort(int *r2,int ,int); //对R 从s 到t 进行快速排序

HANDLE nMutex;

DWORD WINAPI ThreadFunc1(LPVOID n); //冒泡排序

DWORD WINAPI ThreadFunc2(LPVOID n); //快速排序

int main( )

{

srand(time(NULL)); //初始化种子

for(int i=0;i

{

r1[i]=0;

r2[i]=0;

}

for(int i=0;i

{

r1[i]=rand()%100;

}

cout<<"随机产生的数组为:"<

for(int i=0;i

{

cout<

}

cout<

for(int i=0;i

{

r2[i]=r1[i];

}

HANDLE hTread1;

HANDLE hTread2;

hTread1=CreateThread(NULL,0,ThreadFunc1,NULL,0,NULL); //创建线程1

hTread2=CreateThread(NULL,0,ThreadFunc2,NULL,0,NULL) ;//创建线程2

nMutex=CreateMutex(NULL,FALSE,NULL);

CloseHandle(hTread1);

CloseHandle(hTread2);

Sleep(6000);

int a;

cin>>a;

return 0;

}

DWORD WINAPI ThreadFunc1(LPVOID n) //* 线程1负责冒泡排序

{

bubblesort (r1,m);

cout<<"冒泡排序最后结果为:"<

for(int i=0;i

{

cout<

}

cout<

cout<<"冒泡排序结束"<

return 0;

}

DWORD WINAPI ThreadFunc2(LPVOID n)

{

quicksort(r2,0,m-1);

cout<<"快速排序最后结果为:"<

for(int i=0;i

{

cout<

}

cout<

cout<<"快速排序结束"<

return 0;

}

void bubblesort(int *r1,int m)

{

int i1,j1,exchange;

int temp;

for(i1=0;i1<=m-1;i1++)

{

exchange=0;

for(j1=m-1;j1>=i1;j1--)

{

if(r1[j1]

{

WaitForSingleObject(nMutex,INFINITE);

Sleep(100);

temp=r1[j1];

r1[j1]=r1[j1-1];

r1[j1-1]=temp;

exchange=1;

count++;

cout<<"冒泡排序第"<

for(int k1=0;k1

{

cout<

}

cout<

ReleaseMutex(nMutex);

}

}

if(exchange==0) return;

}

}

void quicksort(int *r2,int s,int t)

{

int i=s, j=t;

int temp;

if(s

{

temp=r2[s];

while(i! = j)

{

while(j>i&&r2[j]>=temp)

j--;

while(i

i++;

int x=r2[i];

r2[i]=r2[j];

r2[j]=x;

}

r2[s]=r2[j];

r2[i]=temp;

count1++;

WaitForSingleObject(nMutex,INFINITE);

Sleep(100);

cout<<"快速排序第"<

for(int k=0;k

{

cout<

}

cout<

ReleaseMutex(nMutex);

quicksort(r2,s,j-1);

quicksort(r2,j+1,t);

}

}

不是多此一举,

如果你不sleep,就会引起某些模块分不到时间片,导致锁,进而性能下降。

不只是多线程,单线程的循环里面也要写sleep(1)这样的代码。

同意10楼,实际程序中需要多线程的都是一些耗时的操作,而在写多线程同步的演示程序时为了简化略去了复杂的业务操作,但是这样就会导致程序执行过快,从而体现不出同步的效果,另一方面执行过快还会掩盖一些在耗时操作下才会暴露出的不使用同步导致的问题,例如火车站售票的那个例子

于是在写多线程同步的程序时就加上Sleep来模拟实际使用中的耗时操作,便于清晰地体现出等待资源等等操作的效果

请看一段简单的多线程代码:

ThreadA(LPVOID lp)

{

WaitForSingleObject(hEvent, INFINITE); // WaitForSingleObject(hEvent1, INFINITE); ResetEvent(hEvent); // ResetEvent(hEvent1)

......

//do something

......

SetEvent(hEvent); // SetEvent(hEvent2)

}

ThreadB(LPVOID lp)

{

WaitForSingleObject(hEvent, INFINITE); // WaitForSingleObject(hEvent2, INFINITE); ResetEvent(hEvent);

......

//do something

SetEvent(hEvent); // SetEvent(hEvent1)

Sleep(5000); //这个问题的关键处

WaitForSingleObject(hEvent, INFINITE); // WaitForSingleObject(hEvent2, INFINITE) ResetEvent(hEvent); // ResetEvent(hEvent2);

//do something

......

SetEvent(hEvent); // SetEvent(hEvent2);

}

我的本意是希望能够在ThreadB执行Sleep()的时候切换到ThreadA,等ThreadA执行完,再继续去执行ThreadB中Sleep()之后的代码。

但是现在的情况是:

当ThreadB执行Sleep()时,ThreadA并没有按想象的去执行代码。而是等待整个ThreadB 函数结束以后,才开始运行。

请问这是什么原因?如何解决?

sleep只是当前线程放弃cpu,重新进入调度。但不保证会执行哪个。你有两个线程互相等

待,应该用两个event。(看一下mfc的thrdcore.cpp,mfc线程启动afxbeginthread也用到了这种方法)。

从程序看,你还存有单线程的思想,认为程序是按你想象的顺序执行,实际并非如此。sleep只会让当前线程放弃cpu,谁获得cpu是随机得