异步io中用WaitforsingleOjbect是不是个有问题的设计

[zrdongjiao]

#include<windows.h>

#include <stdio.h>


int main()
{
#define  BUFFER_SIZE	1024*1024*1024		//1GB
	char buf[BUFFER_SIZE];
	
	HANDLE hfile;
	
	OVERLAPPED ol;
	
	//初始化
	
	memset(buf,0,BUFFER_SIZE);
	memset(&ol,0,sizeof(ol));
	
	
	hfile=CreateFile("g:\\VS2012_RC_ULT_CHS.iso",
		GENERIC_READ | GENERIC_WRITE,
		FILE_SHARE_READ|FILE_SHARE_WRITE,
		NULL,
		OPEN_EXISTING,
		FILE_FLAG_OVERLAPPED,NULL
		);
	
	if(INVALID_HANDLE_VALUE==hfile)
	{
		printf("opend file erorr\n");
		return		-1;
	}
	
	
	ol.Offset=0;
	
	DWORD numRead;
	
	
	BOOL bRet=ReadFile(hfile,buf,BUFFER_SIZE,&numRead,&ol);
	
	if(bRet)
	{
		
	}
	
	else
	{
		if(ERROR_IO_PENDING==GetLastError())		//说明在读
		{
			
			
			//难道我在这里等待吗？？ 等待岂不是傻乎?
			WaitForSingleObject(hfile,-1);
			//等多久??
			//查询结果
			
			bRet=GetOverlappedResult(hfile,&ol,&numRead,TRUE);
			
			if(TRUE==bRet)		//读取完毕
			{
				
			}
			else				//出错了
			{
				
			}
			
			
		}

	}

		
		CloseHandle(hfile);
		
		return 0;
		
	}

异步肯定要比同步好， 如果不好，设计它就是吃多了，

我提供的代码， 大家看吧，用了WaitforSingleObject，不用不行，不知道什么时候读取完毕？

可是用了， 和同步有什么区别，不也得等待， 这不是扯嘛？


问题2：为什么说 重叠io有事件对象这东西，我的代码里怎么没有??

[zrdongjiao]

缓冲区大小修改了，程序可以运行，为什么跟踪后，缓冲区大小是空的呢?


没有读取到任何数据啊






#include<windows.h>

#include <stdio.h>


int main()
{
#define BUFFER_SIZE 1024 //1GB
char buf[BUFFER_SIZE];

HANDLE hfile;

OVERLAPPED ol;

//初始化

memset(buf,0,BUFFER_SIZE);
memset(&ol,0,sizeof(ol));


hfile=CreateFile("g:\\VS2012_RC_ULT_CHS.iso",
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ|FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
FILE_FLAG_OVERLAPPED,NULL
);

if(INVALID_HANDLE_VALUE==hfile)
{
printf("opend file erorr\n");
return -1;
}


ol.Offset=0;

DWORD numRead;


BOOL bRet=ReadFile(hfile,buf,BUFFER_SIZE,&numRead,&ol);

if(bRet)
{

}

else
{
if(ERROR_IO_PENDING==GetLastError()) //说明在读
{


//难道我在这里等待吗？？ 等待岂不是傻乎?
WaitForSingleObject(hfile,-1);

//等多久??
//查询结果

bRet=GetOverlappedResult(hfile,&ol,&numRead,TRUE);

if(TRUE==bRet) //读取完毕
{

}
else //出错了
{

}


}

}

CloseHandle(hfile);

return 0;

}

[Eleven]

异步的话，ReadFile没有完成的话也会返回，继续往下执行（你可以去做其它的事情，不用耗在这里傻等），同步的话，就会卡在ReadFile，直到成功返回或者出错。

[schlafenhamster]

WaitForSingleObject(hfile,-1);
你在等，CPU并不等，在SingleObject前CPU会干别的（界面）

[zrdongjiao]

有没有天理？

WaitForsingleobject本质就是一个 等待函数

后续代码只有当 有信号的时候，则返回，然后执行后续代码

cpu没有等？

什么嘛意思啊




[Quote=引用 3 楼 的回复:]

WaitForSingleObject(hfile,-1);
你在等，CPU并不等，在SingleObject前CPU会干别的（界面）
[/Quote]

[zrdongjiao]

你能提供一段代码嘛？

做什么工作呢？





[Quote=引用 2 楼 的回复:]

异步的话，ReadFile没有完成的话也会返回，继续往下执行（你可以去做其它的事情，不用耗在这里傻等），同步的话，就会卡在ReadFile，直到成功返回或者出错。
[/Quote]

[schlafenhamster]

Remarks
The WaitForSingleObject function checks the current state of the specified object. If the object's state is nonsignaled, the calling thread enters an efficient wait state. The thread consumes very little processor time while waiting for the object state to become signaled or the time-out interval to elapse.

Before returning, a wait function modifies the state of some types of synchronization objects. Modification occurs only for the object whose signaled state caused the function to return. For example, the count of a semaphore object is decreased by one.

[zrdongjiao]

感谢你的资料

总结：WaitForSingleobject 还是会等，等时间或者信号，只是消耗cpu过少。

可是还是要等啊


和我的主贴有什么关系呢？

关键代码：

else
{
if(ERROR_IO_PENDING==GetLastError()) //说明在读
{


//难道我在这里等待吗？？ 等待岂不是傻乎?
WaitForSingleObject(hfile,-1);
//等多久??
//查询结果

bRet=GetOverlappedResult(hfile,&ol,&numRead,TRUE);

if(TRUE==bRet) //读取完毕
{

}
else //出错了
{

}


1. 假设把这段代码放到子线程中（工作线程） ，然后执行， 子线程也得等

2.凡在主线程中，还是要等。

3. 无论放到哪里，都得到。 或许放到子线程中， 不耗cpu罢了。（因为用了异步io)

如果改成 同步 io， 不采用 重叠io，那么放在线程中， 难道耗cpu嘛/



书上引入这个概念，多半是说， 同步耗时间，异步可以节约， 我实在看不出有什么好处来？
都得等




[Quote=引用 6 楼 的回复:]

Remarks
The WaitForSingleObject function checks the current state of the specified object. If the object's state is nonsignaled, the calling thread enters an efficient wait state. The thread consume……
[/Quote]

[stjay]

1.无论同步、异步，都得有个线程去等待其完成信号，都要等，只是等待方式不同
异步IO，可使ReadFile和WaitForSingleObject之间可以做其他事
你做过IOCP（特别是socket）的话，就会体会到异步的真正意义
因为平时读写就只这么几个文件，阻塞方式就足够了
2.WaitForSingleObject(hfile,-1);是错的，不能用文件句柄

[zrdongjiao]

不用文件句柄，那么如何修改呢？



[Quote=引用 8 楼 的回复:]
1.无论同步、异步，都得有个线程去等待其完成信号，都要等，只是等待方式不同
异步IO，可使ReadFile和WaitForSingleObject之间可以做其他事
你做过IOCP（特别是socket）的话，就会体会到异步的真正意义
因为平时读写就只这么几个文件，阻塞方式就足够了
2.WaitForSingleObject(hfile,-1);是错的，不能用文件句柄
[/Quote]

[smwhotjay]

LZ还在困惑异步的效率啊. WaitForSingleObject只是单个等待.
实际高效率的io是不能接受的,所以萎软才又出了个 WaitForMultiObjectsEx 同时等待64个对象.
然后iocp.则可以一个线程"等待"无限个对象(其实应该叫取io完成结果)

[schlafenhamster]

看看操作系统的线程调度。
‘The thread consumes very little processor time’
就是说操作系统可以调度别的线程运行。

[zdleek]

楼主有点心浮气躁，自己学艺不精不要随便喷，请多读书多看报多学习原理多研究代码

[henry.x]

支持楼上，异步和同步的却别 很大 ，处理方式 也 大不相同 ，不知道 楼主 用过 WinINet 没有, 简单的 说 同步是要 一直 阻塞下去 ，而异步 是 直接 返回 ，但是在 另一个线程中进行处理结果，或者是在回调函数中 进行处理结果 。

[henry.x]

支持楼上，异步和同步的却别 很大 ，处理方式 也 大不相同 ，不知道 楼主 用过 WinINet 没有, 简单的 说 同步是要 一直 阻塞下去 ，而异步 是 直接 返回 ，但是在 另一个线程中进行处理结果，或者是在回调函数中 进行处理结果 。

[zrdongjiao]

我买了本书，书这样解释的， 我能如何嗯

这个例子是来自一本书，

书上随便就说了几句话，效率高，什么的

能提供一个 正确的 例子吗？




[Quote=引用 12 楼 的回复:]

楼主有点心浮气躁，自己学艺不精不要随便喷，请多读书多看报多学习原理多研究代码
[/Quote]