博客园_我思考..我存在..

java monitor file

2011-03-15T10:08:00Z

/Files/nanshouyong326/testJNotify.rar

本文链接

java mina unix client

2011-03-15T10:04:00Z

/Files/nanshouyong326/MinaTest.rar

本文链接

asp.net 跑 socket server

2011-02-24T06:35:00Z

/Files/nanshouyong326/HttpModle_server.rar

本文链接

epoll 多线程服务器

2010-12-21T08:42:00Z

  1 //
  2 // a simple agi server using epoll in linux
  3 //
  4 // 2010-12-20
  5 // by nsy
  6 //
  7 #include <sys/socket.h>
  8 #include <sys/epoll.h>
  9 #include <netinet/in.h>
10 #include <arpa/inet.h>
11 #include <fcntl.h>
12 #include <unistd.h>
13 #include <stdio.h>
14 #include <stdlib.h>
15 #include <errno.h>
16 #include <string.h>
17 #include "CallSvr.h"
18 #include <pthread.h>
19 #include "epoll.h"
20
21 //test
22 #include "msg.h"
23
24 // set event
25 void EventSet(struct myevent_s *ev, int fd,int status)
26 {
27   ev->fd = fd;
28   ev->status = status;
29   ev->last_active = time(NULL);
30   fprintf(stderr,"function=%s,line=%d,fd=%d\n",__func__,__LINE__,fd);
31 }
32 // add/mod an event to epoll
33 void EventAdd(int epollFd, int events,struct myevent_s *ev)
34 {
35   struct epoll_event epv = {0, {0}};
36   int op;
37   epv.data.ptr = ev;
38   epv.events = events;
39   if(ev->status == 1){
40     op = EPOLL_CTL_MOD;
41     fprintf(stderr,"mod:function=%s,line=%d,fd=%d,status=%d\n",__func__,__LINE__,ev->fd,ev->status);
42   }
43   else{
44     op = EPOLL_CTL_ADD;
45     ev->status = 1;
46     fprintf(stderr,"add:function=%s,line=%d,fd=%d,status=%d\n",__func__,__LINE__,ev->fd,ev->status);
47   }
48   if(epoll_ctl(epollFd, op, ev->fd, &epv) < 0)
49     {
50       fprintf(stderr,"failed:function=%s,line=%d,fd=%d:errno=%d\n",__func__,__LINE__,ev->fd,errno);
51     }
52   else
53     {
54       fprintf(stderr,"success:function=%s,line=%d,fd=%d\n",__func__,__LINE__,ev->fd);
55     }
56 }
57 // delete an event from epoll
58 void EventDel(int epollFd,struct myevent_s *ev)
59 {
60   struct epoll_event epv = {0, {0}};
61   if(ev->status != 1) return;
62   epv.data.ptr = ev;
63   ev->status = 0;
64   epoll_ctl(epollFd, EPOLL_CTL_DEL, ev->fd, &epv);
65   fprintf(stderr,"function=%s,line=%d,fd=%d\n",__func__,__LINE__,ev->fd);
66 }
67
68 // receive data
69 void RecvData(struct myevent_s *ev)
70 {
71   msg_header header;
72   int recvbytes;
73   if ((recvbytes=recv(ev->fd, &header, sizeof(msg_header), 0)) ==-1)
74     {
75       fprintf(stderr,"RecvHeaderErr:function=%s,line=%d,fd=%d\n",__func__,__LINE__,ev->fd);
76       goto errret;
77     }
78   if(recvbytes == sizeof(msg_header))
79     {
80       switch(header.msg_type)
81     {
82     case msg_lost:
83       {
84         rq_lost rq;
85         if ((recvbytes=recv(ev->fd, ((char*)(&rq))+sizeof(msg_header), sizeof(rq_lost)-sizeof(msg_header), 0)) ==-1)
86           {
87         fprintf(stderr,"RecvAfter:function=%s,line=%d,fd=%d\n",__func__,__LINE__,ev->fd);
88         goto errret;
89           }
90         else if(recvbytes > 0)
91           {
92         printf("recv sucess%d,hope to recv %d\n",recvbytes,sizeof(rq_lost)-sizeof(msg_header));
93         printf("cardno is '%s'\n",rq.cardno);
94         printf("password is '%s'\n",rq.password);
95
96         //init ev recv
97         memcpy(&ev->header,&header,sizeof(msg_header));
98         memcpy(&ev->recv_buff,&rq,sizeof(rq_lost));
99         ev->recv_len = recvbytes;
100         fprintf(stderr,"addtologicqueue:function=%s,line=%d,fd=%d\n",__func__,__LINE__,ev->fd);
101         //add to logic queue
102         sem_wait(&bin_sem_logic_data_produce);
103         struct QUEUE_LOGIC_DATA_ITEM *item;
104         item = malloc(sizeof(struct QUEUE_LOGIC_DATA_ITEM));
105         item->ev = ev;
106         pthread_mutex_lock(&queue_logic_data_mutex);
107         TAILQ_INSERT_TAIL(&queue_logic_data_header,item,logic_data_entries);
108         pthread_mutex_unlock(&queue_logic_data_mutex);
109         sem_post(&bin_sem_logic_data_consume);
110         fprintf(stderr,"addtologicqueue--end:function=%s,line=%d,fd=%d\n",__func__,__LINE__,ev->fd);
111           }else
112           {
113         fprintf(stderr,"RecvAfter:function=%s,line=%d,fd=%d:errno=%d\n",__func__,__LINE__,ev->fd,errno);
114         goto errret;
115           }
116         break;
117       }
118     }
119       return;//switch end function end
120     }else
121     {
122       fprintf(stderr,"function=%s,line=%d,fd=%d\n",__func__,__LINE__,ev->fd);
123       goto errret;
124     }
125  errret:
126   EventDel(g_epollFd, ev);
127   close(ev->fd);
128 }
129 // send data
130 void SendData(struct myevent_s *ev)
131 {
132   fprintf(stderr,"JustIn:function=%s,line=%d,fd=%d\n",__func__,__LINE__,ev->fd);
133   int len;
134   // send data
135   len = send(ev->fd, ev->send_buff, ev->send_len, 0);
136   ev->send_len = 0;
137   fprintf(stderr,"sendlen=%d:function=%s,line=%d,fd=%d\n",len,__func__,__LINE__,ev->fd);
138   if(len < 0)
139     {
140       close(ev->fd);
141       fprintf(stderr,"err=%d:function=%s,line=%d,fd=%d\n",errno,__func__,__LINE__,ev->fd);
142     }else
143     {
144       //let system known can recv
145       EventAdd(g_epollFd, EPOLLIN|EPOLLET,ev);
146     }
147 }
148
149 void *accept_thread_work(void *arg)
150 {
151   while(1)
152     {
153       int* plistenFd = (int*)arg;
154       fprintf(stderr,"function=%s,line=%d,listenfd=%d\n",__func__,__LINE__,*plistenFd);
155       struct sockaddr_in sin;
156       socklen_t len = sizeof(struct sockaddr_in);
157       int nfd, i;
158       // accept
159       if((nfd = accept(*plistenFd, (struct sockaddr*)&sin, &len)) == -1)
160     {
161       if(errno != EAGAIN && errno != EINTR)
162         {
163           fprintf(stderr,"%s: bad accept", __func__);
164         }
165       continue;
166     }
167       do
168     {
169       for(i = 0; i < MAX_EVENTS; i++)
170         {
171           if(g_Events[i].status == 0)
172         {
173           fprintf(stderr,"function=%s,line=%d,listenfd=%d,currentindex=%d\n",__func__,__LINE__,*plistenFd,i);
174           break;
175         }
176         }
177       if(i == MAX_EVENTS)
178         {
179           fprintf(stderr,"max events:function=%s,line=%d,listenFd=%d\n",__func__,__LINE__,*plistenFd);
180           break;
181         }
182       // set nonblocking
183       fprintf(stderr,"set nonblocking:function=%s,line=%d,listenfd=%d\n",__func__,__LINE__,*plistenFd);
184       if(fcntl(nfd, F_SETFL, O_NONBLOCK) < 0) break;
185       // add a read event for receive data
186       EventSet(&g_Events[i], nfd,0);
187       EventAdd(g_epollFd, EPOLLIN|EPOLLET, &g_Events[i]);
188       fprintf(stderr,"new conn[%s:%d][time:%d]\n", inet_ntoa(sin.sin_addr), ntohs(sin.sin_port),(int) g_Events[i].last_active);
189     }while(0);
190     }
191   return NULL;
192 }
193
194 void *epoll_wait_thread_work(void *arg)
195 {
196   fprintf(stderr,"justin:function=%s,line=%d\n",__func__,__LINE__);
197   // event loop
198   struct epoll_event events[MAX_EVENTS];
199
200   int checkPos = 0;
201   while(1){
202     // a simple timeout check here, every time 100, better to use a mini-heap, and add timer event
203     long now = time(NULL);
204     int i;
205     for(i = 0; i < 100; i++, checkPos++) // doesn't check listen fd
206       {
207     if(checkPos == MAX_EVENTS) checkPos = 0; // recycle
208     if(g_Events[checkPos].status != 1) continue;
209     long duration = now - g_Events[checkPos].last_active;
210     if(duration >= 60) // 60s timeout
211       {
212         close(g_Events[checkPos].fd);
213         fprintf(stderr,"[fd=%d] timeout[%d--%d].\n",(int) g_Events[checkPos].fd,(int) g_Events[checkPos].last_active, (int)now);
214         EventDel(g_epollFd, &g_Events[checkPos]);
215       }
216       }
217     // wait for events to happen
218     int fds = epoll_wait(g_epollFd, events, MAX_EVENTS, 1000);
219     if(fds < 0){
220       fprintf(stderr,"epoll_wait error, exit\n");
221       break;
222     }
223     for(i = 0; i < fds; i++){
224       struct myevent_s *ev = (struct myevent_s*)events[i].data.ptr;
225       if(events[i].events&EPOLLIN) // read event
226     {
227       sem_wait(&bin_sem_recv_fd_produce);
228       fprintf(stderr,"readEvent:function=%s,line=%d:fd=%d\n",__func__,__LINE__,ev->fd);
229       //ev->call_back(ev->fd, events[i].events, ev->arg);
230       struct QUEUE_RECV_FD_ITEM *item;
231       item = malloc(sizeof(struct QUEUE_RECV_FD_ITEM));
232       item->ev = ev;
233       pthread_mutex_lock(&queue_recv_fd_mutex);
234       TAILQ_INSERT_TAIL(&queue_recv_fd_header,item,recv_fd_entries);
235       pthread_mutex_unlock(&queue_recv_fd_mutex);
236       sem_post(&bin_sem_recv_fd_consume);
237     }else if(events[i].events&EPOLLOUT) // write event
238     {
239       sem_post(&bin_sem_send_fd_consume);
240       fprintf(stderr,"post send fd consume:function=%s,line=%d:fd=%d\n",__func__,__LINE__,ev->fd);
241     }
242     }
243   }
244   return NULL;
245 }
246
247 void *recv_data_thread_work(void *arg)
248 {
249   while(1)
250     {
251       sem_wait(&bin_sem_recv_fd_consume);
252       fprintf(stderr,"justin:function=%s,line=%d\n",__func__,__LINE__);
253       int index = (int)arg;
254       fprintf(stderr,"recv thread id is %d\n",index);
255       pthread_mutex_lock(&queue_recv_fd_mutex);
256       struct QUEUE_RECV_FD_ITEM *item;
257       item = TAILQ_FIRST(&queue_recv_fd_header);
258       TAILQ_REMOVE(&queue_recv_fd_header,item,recv_fd_entries);
259       pthread_mutex_unlock(&queue_recv_fd_mutex);
260       RecvData(item->ev);
261     }
262   return NULL;
263 }
264
265 void *send_data_thread_work(void *arg)
266 {
267   while(1)
268     {
269       sem_wait(&bin_sem_send_fd_consume);
270       fprintf(stderr,"justin:function=%s,line=%d\n",__func__,__LINE__);
271       pthread_mutex_lock(&queue_send_fd_mutex);
272       struct QUEUE_SEND_FD_ITEM *item;
273       item = TAILQ_FIRST(&queue_send_fd_header);
274       TAILQ_REMOVE(&queue_send_fd_header,item,send_fd_entries);
275       pthread_mutex_unlock(&queue_send_fd_mutex);
276       SendData(item->ev);
277     }
278   return NULL;
279 }
280
281 void *logic_data_thread_work(void *arg)
282 {
283   while(1)
284     {
285       //remove logic queue
286       sem_wait(&bin_sem_logic_data_consume);
287       //for test
288       int index = (int)arg;
289       fprintf(stderr,"logic thread id is %d\n",index);
290
291       pthread_mutex_lock(&queue_logic_data_mutex);
292       struct QUEUE_LOGIC_DATA_ITEM *item;
293       item = TAILQ_FIRST(&queue_logic_data_header);
294       TAILQ_REMOVE(&queue_logic_data_header,item,logic_data_entries);
295       pthread_mutex_unlock(&queue_logic_data_mutex);
296       //logic header
297       switch(item->ev->header.msg_type)
298     {
299     case msg_lost:
300       {
301         rq_lost* rq = (rq_lost*)item->ev->recv_buff;
302
303         rs_lost rs;
304         rs.header.msg_type = msg_lost;
305         rs.header.size = sizeof(rs_lost);
306         rs.header.length = 0;
307
308         if(strcmp(rq->cardno,"12345")==0)
309           {
310         rs.is_ok = 1;
311           }
312         else
313           {
314         rs.is_ok = 0;
315           }
316         memcpy(&item->ev->header,&rs.header,sizeof(msg_header));
317         item->ev->send_len = sizeof(rs);
318         memcpy(item->ev->send_buff,&rs,sizeof(rs));
319         break;
320       }
321     }
322
323       //add to send fd queue
324       sem_wait(&bin_sem_send_fd_produce);
325       fprintf(stderr,"after wait send fd produce\n");
326       struct QUEUE_SEND_FD_ITEM *sendItem;
327       sendItem = malloc(sizeof(struct QUEUE_SEND_FD_ITEM));
328       sendItem->ev = item->ev;
329       pthread_mutex_lock(&queue_send_fd_mutex);
330       TAILQ_INSERT_TAIL(&queue_send_fd_header,sendItem,send_fd_entries);
331       pthread_mutex_unlock(&queue_send_fd_mutex);
332       //let system known can send
333       EventAdd(g_epollFd, EPOLLOUT|EPOLLET, item->ev);
334     }
335   return NULL;
336 }
337
338 int main(int argc, char **argv)
339 {
340   int res;
341   //recv fd queue
342   TAILQ_INIT(&queue_recv_fd_header);
343   res = sem_init(&bin_sem_recv_fd_consume,0,0);
344   if(res)
345     {
346       fprintf(stderr,"sem init consume failed\n");
347       exit(EXIT_FAILURE);
348     }
349
350   res = sem_init(&bin_sem_recv_fd_produce,0,MAX_EVENTS);
351   if(res)
352     {
353       fprintf(stderr,"sem init produce failed\n");
354       exit(EXIT_FAILURE);
355     }
356
357   res = pthread_mutex_init(&queue_recv_fd_mutex,NULL);
358   if(res!=0)
359     {
360       perror("create mutex for queue recv failed\n");
361       exit(EXIT_FAILURE);
362     }
363   //logic data queue
364   TAILQ_INIT(&queue_logic_data_header);
365   res = sem_init(&bin_sem_logic_data_consume,0,0);
366   if(res)
367     {
368       fprintf(stderr,"sem init logic data consume failed\n");
369       exit(EXIT_FAILURE);
370     }
371
372   res = sem_init(&bin_sem_logic_data_produce,0,MAX_EVENTS);
373   if(res)
374     {
375       fprintf(stderr,"sem init logic data produce failed\n");
376       exit(EXIT_FAILURE);
377     }
378
379   res = pthread_mutex_init(&queue_logic_data_mutex,NULL);
380   if(res!=0)
381     {
382       perror("create mutex for queue logic data failed\n");
383       exit(EXIT_FAILURE);
384     }
385
386   //send fd queue
387   TAILQ_INIT(&queue_send_fd_header);
388   res = sem_init(&bin_sem_send_fd_consume,0,0);
389   if(res)
390     {
391       fprintf(stderr,"sem init send fd consume failed\n");
392       exit(EXIT_FAILURE);
393     }
394
395   res = sem_init(&bin_sem_send_fd_produce,0,MAX_EVENTS);
396   if(res)
397     {
398       fprintf(stderr,"sem init send fd produce failed\n");
399       exit(EXIT_FAILURE);
400     }
401
402   res = pthread_mutex_init(&queue_send_fd_mutex,NULL);
403   if(res!=0)
404     {
405       perror("create mutex for queue send fd failed\n");
406       exit(EXIT_FAILURE);
407     }
408
409   short port = 3342; // default port
410   if(argc == 2){
411     port = atoi(argv[1]);
412   }
413   // create epoll
414   g_epollFd = epoll_create(MAX_EVENTS);
415   if(g_epollFd <= 0)
416     {
417       fprintf(stderr,"create epoll failed:fd=%d:function=%s,line=%d\n", g_epollFd,__func__,__LINE__);
418       exit(EXIT_FAILURE);
419     }
420   // create & bind listen socket
421   int listenFd = socket(AF_INET, SOCK_STREAM, 0);
422   // bind & listen
423   struct sockaddr_in sin;
424   bzero(&sin, sizeof(sin));
425   sin.sin_family = AF_INET;
426   sin.sin_addr.s_addr = INADDR_ANY;
427   sin.sin_port = htons(port);
428   bind(listenFd, (const struct sockaddr*)&sin, sizeof(sin));
429   listen(listenFd, 5);
430   fprintf(stderr,"server running:port[%d]\n", port);
431   //create accept thread
432
433   void *thread_result;
434   pthread_t accept_t;
435   res = pthread_create(&accept_t,NULL,accept_thread_work,(void *)&listenFd);
436   if(res != 0)
437     {
438       perror("accept create failed\n");
439       exit(EXIT_FAILURE);
440     }
441
442   //create epoll wait thread
443   pthread_t epoll_wait_t;
444   res = pthread_create(&epoll_wait_t,NULL,epoll_wait_thread_work,NULL);
445   if(res != 0)
446     {
447       perror("create epoll wait thread failed\n");
448       exit(EXIT_FAILURE);
449     }
450   //create two recv data thread
451   pthread_t recv_data_t;
452   res = pthread_create(&recv_data_t,NULL,recv_data_thread_work,(void*)1);
453   if(res!=0)
454     {
455       perror("create recv data thread failed\n");
456       exit(EXIT_FAILURE);
457     }
458
459   pthread_t recv_data_t_1;
460   res = pthread_create(&recv_data_t_1,NULL,recv_data_thread_work,(void*)2);
461   if(res!=0)
462     {
463       perror("create recv data thread failed\n");
464       exit(EXIT_FAILURE);
465     }
466   //create two send data thread
467   pthread_t send_data_t;
468   res = pthread_create(&send_data_t,NULL,send_data_thread_work,(void*)1);
469   if(res!=0)
470     {
471       perror("create send data thread failed\n");
472       exit(EXIT_FAILURE);
473     }
474
475   pthread_t send_data_t_1;
476   res = pthread_create(&send_data_t_1,NULL,send_data_thread_work,(void*)2);
477   if(res!=0)
478     {
479       perror("create send data thread failed\n");
480       exit(EXIT_FAILURE);
481     }
482
483   //create two logic work thread
484   pthread_t logic_work_t;
485   res = pthread_create(&logic_work_t,NULL,logic_data_thread_work,(void*)1);
486   if(res!=0)
487     {
488       perror("create logic work thread failed\n");
489       exit(EXIT_FAILURE);
490     }
491
492  pthread_t logic_work_t_1;
493   res = pthread_create(&logic_work_t_1,NULL,logic_data_thread_work,(void*)2);
494   if(res!=0)
495     {
496       perror("create logic work thread failed\n");
497       exit(EXIT_FAILURE);
498     }
499
500   //wait child thread
501   res = pthread_join(accept_t,&thread_result);
502   if(res!=0)
503     {
504       perror("accept thread join failed\n");
505       exit(EXIT_FAILURE);
506     }
507
508   //wait child thread
509   res = pthread_join(epoll_wait_t,&thread_result);
510   if(res!=0)
511     {
512       perror("epoll wait thread join failed\n");
513       exit(EXIT_FAILURE);
514     }
515
516   //wait child thread
517   res = pthread_join(recv_data_t,&thread_result);
518   if(res!=0)
519     {
520       perror("recv data thread join failed\n");
521       exit(EXIT_FAILURE);
522     }
523   //wait child thread
524   res = pthread_join(recv_data_t_1,&thread_result);
525   if(res!=0)
526     {
527       perror("recv data thread join failed\n");
528       exit(EXIT_FAILURE);
529     }
530
531   //wait child thread
532   res = pthread_join(send_data_t,&thread_result);
533   if(res!=0)
534     {
535       perror("send data thread join failed\n");
536       exit(EXIT_FAILURE);
537     }
538   //wait child thread
539   res = pthread_join(send_data_t_1,&thread_result);
540   if(res!=0)
541     {
542       perror("send data thread join failed\n");
543       exit(EXIT_FAILURE);
544     }
545   //wait child thread
546   res = pthread_join(logic_work_t,&thread_result);
547   if(res!=0)
548     {
549       perror("logic work thread join failed\n");
550       exit(EXIT_FAILURE);
551     }
552   //wait child thread
553   res = pthread_join(logic_work_t_1,&thread_result);
554   if(res!=0)
555     {
556       perror("logic work thread join failed\n");
557       exit(EXIT_FAILURE);
558     }
559   // free resource
560   close(g_epollFd);
561   sem_destroy(&bin_sem_recv_fd_consume);
562   sem_destroy(&bin_sem_recv_fd_produce);
563   pthread_mutex_destroy(&queue_recv_fd_mutex);
564
565   sem_destroy(&bin_sem_logic_data_consume);
566   sem_destroy(&bin_sem_logic_data_produce);
567   pthread_mutex_destroy(&queue_logic_data_mutex);
568
569   sem_destroy(&bin_sem_send_fd_consume);
570   sem_destroy(&bin_sem_send_fd_produce);
571   pthread_mutex_destroy(&queue_send_fd_mutex);
572   return 0;
573

1 #ifndef _epoll_h_
2 #define _epoll_h_
3
4 #include "sys/queue.h"
5 #include <semaphore.h>
6 #include "msg.h"
7
8 #define MAX_EVENTS 500
9
10 int g_epollFd;
11
12 void *accept_thread_work(void *arg);
13 void *epoll_wait_thread_work(void *arg);
14 void *recv_data_thread_work(void *arg);
15 void *send_data_thread_work(void *arg);
16 void *logic_data_thread_work(void *arg);
17
18 struct myevent_s
19 {
20   int fd;
21   int status; // 1: in epoll wait list, 0 not in
22   msg_header header;
23   char recv_buff[256]; // recv data buffer
24   int recv_len;
25   char send_buff[256];//send data buffer
26   int send_len;
27   long last_active; // last active time
28 };
29
30 struct myevent_s g_Events[MAX_EVENTS+1]; // g_Events[MAX_EVENTS] is used by listen fd
31
32 //recv fd queue
33 struct QUEUE_RECV_FD_ITEM{
34   struct myevent_s* ev;
35   TAILQ_ENTRY(QUEUE_RECV_FD_ITEM) recv_fd_entries;
36 };
37
38 TAILQ_HEAD(,QUEUE_RECV_FD_ITEM) queue_recv_fd_header;
39
40 sem_t bin_sem_recv_fd_produce;
41 sem_t bin_sem_recv_fd_consume;
42
43 pthread_mutex_t queue_recv_fd_mutex;
44
45 //send fd queue
46 struct QUEUE_SEND_FD_ITEM{
47   struct myevent_s* ev;
48   TAILQ_ENTRY(QUEUE_SEND_FD_ITEM) send_fd_entries;
49 };
50
51 TAILQ_HEAD(,QUEUE_SEND_FD_ITEM) queue_send_fd_header;
52
53 sem_t bin_sem_send_fd_produce;
54 sem_t bin_sem_send_fd_consume;
55
56 pthread_mutex_t queue_send_fd_mutex;
57
58 //logic data buff
59 struct QUEUE_LOGIC_DATA_ITEM{
60   struct myevent_s* ev;
61   TAILQ_ENTRY(QUEUE_LOGIC_DATA_ITEM) logic_data_entries;
62 };
63
64 TAILQ_HEAD(,QUEUE_LOGIC_DATA_ITEM) queue_logic_data_header;
65
66 sem_t bin_sem_logic_data_produce;
67 sem_t bin_sem_logic_data_consume;
68
69 pthread_mutex_t queue_logic_data_mutex;
70
71 #endif
72

}

本文链接

PAZU 是4Fang 为配合“四方在线”软件于2004年开发的WEB打印控件，适用于各种WEB软件项目的打印。

2010-11-01T03:45:00Z

PAZU 是4Fang 为配合“四方在线”软件于2004年开发的WEB打印控件，适用于各种WEB软件项目的打印。

PAZU是客户端软件，使用于IE作为客户端的所有应用，与服务器端开发语言无关，即PAZU支持所有的开发语言开发的WEB应用，无论是Java还是Dot Net还是PHP 还是…都没有问题，客户端是IE就可以了。

如果你的应用的客户端不是IE，是firefox/chrome等非IE浏览器，您就需要PAZU的NP版本(NP版本我们的项目小组正在内部测试，估计在2009年10月份会推出给大家使用，敬请留意)

PAZU广泛支持IE6、IE7、IE8，支持WinXP以上操作系统，包括Windows Vista 和 Windows 7。

PAZU还支持IE内核的非IE浏览器，如傲游、QQ浏览器、世界之窗等。

PAZU还支持使用IE浏览器编程对象自己编写的各种应用浏览器。

由于Windows Vista 以上操作系统和IE8以上版本在系统权限校验、安全性方面的巨大提升，使得目前网上公布的绝大部分WEB打印控件都不能完美支持WinVista和Win7、IE8等新一代WEB应用平台。PAZU的开发小组花费了大量的时间来使得PAZU具备最完全的兼容能力。

PAZU于2005年投入正式商用，是国内最早的WEB打印控件，被广大客户和朋友广泛应用于：电信、移动通信、银行、政府、医院、教育等各种大型应用中，这些前期付费的用户为PAZU和4Fang的发展贡献了宝贵的“粮草”，在此我们对前期付费购买PAZU许可的所有客户朋友表示最高的敬意。

2009年6月，4Fang 决定自2009年6月20日起，PAZU完全无限制免费推出，4Fang迈出的这一步这标志着4Fang的策略由一家相对技术封闭的应用软件开发公司走向技术开放的新里程。4Fang 将以：

标准、开放、易用

为新的技术指导策略，团结和凝聚更多的开发人员，为用户提供最简单实用的应用软件产品。4Fang 陆续还会开放4Fang专有WEB应用平台—LAPUTAC (一个同时支持数据在服务器、客户端存储，同时支持WEB应用模式和单独打包模式的领先应用平台，详见http://www.4Fang.net/apps/SaaS/ )

PAZU 的永久主站网址 http://www.4Fang.net/tech/pazu.html

PAZU 的永久下载网址 http://www.4Fang.net/4ff/sc_setup.exe

PAZU 开发包下载网址 http://www.4Fang.net/4ff/pazu.rar

PAZU的讨论和意见反馈请到4Fang的论坛 http://www.4Fang.net/BBS/

本文链接

jbpm表说明

2010-07-30T05:31:00Z

http://www.blogjava.net/wenlong/archive/2009/09/18/295593.html

JBPM数据库表说明

1 流程配置类数据库表：

1.1 JBPM_PROCESSDEFINITION：流程模版表

字段名	字段含义	主键	外键
ID_	流程模版标识	√	×
NAME_	流程模版名称	×	×
VERSION_	流程模版版本，对于同一流程模版，多次插入数据库时，数据库中有多条记录，每条记录中的版本号一次增加	×	×
ISTERMINATIONIMPLICIT_	是否支持强行终止流程（目前理解）	×	×
STARTSTATE_	起始节点ID，在JBPM_NODE表中	×	√

1.2 JBPM_NODE：流程节点表

字段名	字段含义	主键	外键
ID_	流程节点标识	√
CLASS_	节点类型： C: org.jbpm.graph.node.ProcessState D: org.jbpm.graph.node.Decision E: org.jbpm.graph.node.EndState F: org.jbpm.graph.node.Fork J: org.jbpm.graph.node.Join K: org.jbpm.graph.node.TaskNode N: org.jbpm.graph.def.Node R: org.jbpm.graph.node.StartState S: org.jbpm.graph.node.State U: org.jbpm.graph.def.SuperState
NAME_	流程节点名称
SUBPROCESSDEFINITION_	节点类型为ProcessState时使用，代表子流程模版id		√
ISASYNC_	节点是否支持异步机制
ACTION_	节点中指定的action，对应JBPM_ACTION表		√
SUPERSTATE_	节点对应的SuperState的id，表明该节点属于某个SuperState		√
PROCESSDEFINITION_	节点所在的流程模版id		√
DECISIONDELEGATION	节点类型为Decision时使用，表明Decision对应的代理类，对应JBPM_DELEGATION表		√
DECISIONEXPRESSION_	节点类型为Decision时使用，该属性表示Decision中使用的判断表达式
SIGNAL_	节点类型为Task
CREATETASKS_	节点类型为Task
ENDTASKS_	节点类型为Task
NODECOLLECTIONINDEX_	节点类型为SuperState时使用，

1.3 JBPM_TRANSITION：流程迁移表

字段名	字段含义	主键	外键
ID_	流程迁移标识	√
NAME_	流程迁移名称
PROCESSDEFINITION_	迁移所在的流程模版id		√
FROM_	迁移来源，对应Node的id		√
TO_	迁移目的，对应Node的id		√
FROMINDEX_	？

1.4 JBPM_ACTION：流程动作表

字段名	字段含义	主键	外键
ID_	流程动作标识	√
NAME_	流程动作名称		√
CLASS_	流程动作分类： A（动作）: org.jbpm.graph.def.Action S（脚本）: org.jbpm.graph.action.Script C（创建定时器）: org.jbpm.scheduler.def.CreateTimerAction I（取消定时器）: org.jbpm.scheduler.def.CancelTimerAction
ISPROPAGATIONALLOWED_	？
ACTIONEXPRESSION_	动作类行为I时使用，表示动作执行的脚本
ISASYNC_	动作是否支持异步机制
REFERENCEDACTION_	动作中引用的动作，对应JBPM_ACTION		√
ACTIONDELEGATION_	动作类型为A时使用，表示动作执行的代理类，对应JBPM_DELEGATION		√
EVENT_	动作中指定的事件，对应JBPM_EVENT
PROCESSDEFINITION_	动作所在的流程模版id		√
TIMERNAME_	定时器名称
DUEDATE_	定时器间隔时间
REPEAT_	定时器动作执行次数
TRANSITIONNAME_	动作指定后指向的Transition
TIMERACTION_	定时器动作代理类，对应JBPM_ACTION
EXPRESSION_	定时器执行表达式
EVENTINDEX_	？
EXCEPTIONHANDLER_	异常处理类，对应JBPM_ EXCEPTIONHANDLER
EXCEPTIONHANDLERINDEX_	？

1.5 JBPM_EVENT：流程事件表

字段名	字段含义	主键	外键
ID_	流程事件标识	√
EVENTTYPE_	流程事件类型名称
TYPE_	流程事件所在的图形节点类型 "A" ：Task "C" ：ProcessState "D" ：Decision" "E" ：EndState" "F" ：Fork" "J" ：Join" "K" ：TaskNode" "N" ：Node" "P" ：ProcessDefinition" "R" ：StartState" "S" ：State" "T" ：Transition" "U" ：SuperState"
GRAPHELEMENT_	流程事件所在的图形节点的ID
PROCESSDEFINITION_	流程事件所属流程定义，对应JBPM_PROCESSDEFINITION		√
NODE_	流程事件所属节点，对应JBPM_NODE		√
TRANSITION_	流程事件所属迁移，对应JBPM_ TRANSITION		√
TASK_	流程事件所属任务，对应JBPM_TASK		√

1.6 JBPM_DELEGATION：流程代理类表（用于实例化jbpm中的action类）

字段名	字段含义	主键	外键
ID_	流程代理标识	√
CLASSNAME_	流程代理类名称
CONFIGURATION_	流程代理类配置信息
CONFIGTYPE_	流程代理类配置类型
PROCESSDEFINITION_	流程代理类所属流程定义，对应JBPM_PROCESSDEFINITION		√

1.7 JBPM_TASK：流程任务表

字段名	字段含义	主键	外键
ID_	流程任务标识	√
NAME_	流程任务名称
PROCESSDEFINITION_	流程任务所属流程定义，对应JBPM_PROCESSDEFINITION		√
DESCRIPTION_	流程任务描述
ISBLOCKING_	任务是否为阻塞（任务不完成、流程不能继续）
ISSIGNALING_	任务是否可以驱动TOKEN
DUEDATE	任务持续时间，表明任务应在多长时间内完成
ACTORIDEXPRESSION	?
POOLEDACTORSEXPRESSION	?
TASKMGMTDEFINITION_	任务所属的任务管理模块ID，对应JBPM_MODULEDEFIFNITION		√
TASKNODE_	任务所属的TASK_NODE，对应JBPM_NODE		√
STARTSTATE	任务所属的START_NODE，对应JBPM_NODE		√
ASSIGNMENTDELEGATION	?		√
SWIMLANE	执行该任务的泳道（角色）		√
TASKCONTROLLER_	?

1.8 JBPM_TASKCONTROLLER：流程任务控制器

字段名	字段含义	主键	外键
ID_	流程任务控制器标识	√
TASKCONTROLLERDELEGATION_	流程任务控制器对应的代理，对应JBPM_DELEGATION		√

1.9 JBPM_VARIABLEACCESS：流程变量表

字段名	字段含义	主键	外键
ID_	流程变量标识	√
VARIABLENAME_	流程变量名称
ACCESS_	流程变量存取方式
MAPPEDNAME	？（暂时不使用）
PROCESSSTATE	流程变量所属的流程节点，对应JBPM_NODE		√
TASKCONTROLLER	流程变量所属的流程任务控制器，对应JBPM_ TASKCONTROLLER		√
INDEX_	?
SCRIPT	流程变量所属的ACTION，对应JBPM_ ACTION		√

1.10 JBPM_MODULEDEFINITION：流程模块定义表

字段名	字段含义	主键	外键
ID_	流程模块标识	√
CLASS_	流程模块类型： M : org.jbpm.module.def.ModuleDefinition C : org.jbpm.context.def.ContextDefinition F : org.jbpm.file.def.FileDefinition L: org.jbpm.logging.def.LoggingDefinition I: org.jbpm.scheduler.def.SchedulerDefinition T: org.jbpm.taskmgmt.def.TaskMgmtDefinition
NAME_	流程模块名称
PROCESSDEFINITION_	流程模块所属流程定义，对应JBPM_PROCESSDEFINITION		√
STARTTASK	类型为T时使用，对应JBPM_TASK		√

1.11JBPM_EXCEPTIONHANDLER：流程异常处理器表

字段名	字段含义	主键	外键
ID_	流程异常处理器标识	√
EXCEPTIONHANDLERNAME_	流程异常处理器名称
TYPE_	流程异常处理器所在的图形节点类型 "A" ：Task "C" ：ProcessState "D" ：Decision" "E" ：EndState" "F" ：Fork" "J" ：Join" "K" ：TaskNode" "N" ：Node" "P" ：ProcessDefinition" "R" ：StartState" "S" ：State" "T" ：Transition" "U" ：SuperState"
GRAPHELEMENT_	流程异常处理器所在的图形节点的ID
PROCESSDEFINITION_	流程异常处理器所属流程定义，对应JBPM_PROCESSDEFINITION		√
NODE_	流程异常处理器所属节点，对应JBPM_NODE		√
TRANSITION_	流程异常处理器所属迁移，对应JBPM_ TRANSITION		√
TASK_	流程异常处理器所属任务，对应JBPM_TASK		√
GRAPHELEMENTINDEX_	流程异常处理器中包含的ACTION集合的索引（？）

1.12 JBPM_DECISIONCONDITION：DECISION节点判断条件表

字段名	字段含义	主键	外键
INDEX_	标识	√
DECISION_	所属的DECISION，对应JBPM_NODE	√
TRANSITIONNAME_	DECISION节点的“离开节点名称”
EXPRESSION	每一个“离开节点名称”对应的条件表达式

1.13 JBPM_ SWINLANE：DECISION节点判断条件表

字段名	字段含义	主键	外键
ID_	标识	√
NAME_	泳道名称	√
TRANSITIONNAME_	DECISION节点的“离开节点名称”
EXPRESSION	每一个“离开节点名称”对应的条件表达式

2 流程运行类数据库表：

2.1 JBPM_PROCESSINSTANCE：流程实例表

字段名	字段含义	主键	外键
ID_	标识	√
VERSION_	版本
START_	流程实例开始时间
END_	流程实例结束时间
ISSUSPENDED	流程实例是否暂停
PROCESSDEFINITION_	流程实例所属的流程模版，对应JBPM_PROCESSDEFINITION		√
ROOTTOKEN_	流程实例对应的TOKEN，对应JBPM_TOKEN		√
SUPERPROCESSTOKEN_	父流程的当前TOKEN的ID，当流程实例为子流程实例时使用，表明由父流程进入子流程时，父流程的当前TOKEN。对应JBPM_TOKEN		√

2.2 JBPM_TOKEN：流程TOKEN表

字段名	字段含义	主键	外键
ID_	标识	√
VERSION_	版本
START_	TOKEN开始时间
END_	TOKEN结束时间
NODEENTER_	TOKEN进入当前节点（TOKEN当前所处的节点）的时间
NEXTLOGINDEX_	？
ISABLETOREACTIVATEPARENT_	能否重新激活父TOKEN标志
ISTERMINATIONIMPLICIT_	能够强制终止TOKEN标志
ISSUSPENDED_	TOKEN是否处于暂停状态
NODE_	TOKEN所在的当前节点，对应JBPM_NODE		√
PROCESSINSTANCE_	TOKEN所属的流程实例，对应JBPM_PROCESSINSTANCE		√
PARENT_	TOKEN的父TOKEN，当TOKEN是由fock产生或处于子流程中时使用，对应JBPM_TOKEN		√

2.3 JBPM_LOG：流程日志表

字段名	字段含义	主键	外键
ID_	标识	√
CLASS_	日志类型： A: ActionLog B: ByteArrayUpdateLog C: CompositeLog D: VariableDeleteLog E: DateUpdateLog F: HibernateStringUpdateLog G: LongUpdateLog H: HibernateLongUpdateLog I: ProcessInstanceCreateLog L: DoubleUpdateLog M: MessageLog N: NodeLog O: TokenCreateLog P: ProcessLog R: VariableCreateLog S: SignalLog T: TransitionLog U: StringUpdateLog V: VariableLog W: VariableUpdateLog X: ProcessInstanceEndLog Y: TokenEndLog 0: TaskLog 1: TaskCreateLog 2: TaskAssignLog 3: TaskEndLog 4: SwimlaneLog 5: SwimlaneCreateLog 6: SwimlaneAssignLog
INDEX_	？
DATE_	日志产生时间
TOKEN _	日志所属TOKEN
PARENT_	日志的父日志，对应JBPM_LOG
CHILD_	创建的子TOKEN，对应TokenCreateLog 结束的子TOKEN，对应TokenEndLog
MESSAGE_	消息信息，当日志类型为M（MessageLog）时使用
EXCEPTION_	日志异常信息，对应ActionLog
ACTION_	日志所属ACTION，当日志类型为A（ActionLog）时使用
NODE_	日志所属NODE，当日志类型为N（NodeLog）时使用
ENTER_	进入节点时间，对应NodeLog
LEAVE_	离开节点时间，对应NodeLog
DURATION_	节点停留时间，对应NodeLog
TRANSITION_	日志所属TRANSITION
SOURCENODE_	TRANSITION的起点，对应TransitionLog
DESTINATIONNODE_	TRANSITION的终点，对应TransitionLog
VARIABLEINSTANCE_	日志所属的流程变量实例，对应VariableLog
OLDBYTEARRAY_	原BYTEARRAY值，对应ByteArrayUpdateLog
NEWBYTEARRAY	新BYTEARRAY值，对应ByteArrayUpdateLog
OLDDATEVALUE	原DATE值，对应DateUpdateLog
NEWDATEVALUE	新DATE值，对应DateUpdateLog
OLDDOUBLEVALUE_	原DOUBLE值，对应DoubleUpdateLog
NEWDOUBLEVALUE_	新DOUBLE值，对应DoubleUpdateLog
OLDLONGIDCLASS_	原LONGIDCLASS值，对应HibernateLongUpdateLog
NEWLONGIDCLASS_	新LONGIDCLASS值，对应HibernateLongUpdateLog
OLDLONGIDVALUE_	原LONGID值，对应HibernateLongUpdateLog
NEWLONGIDVALUE_	新LONGID值，对应HibernateLongUpdateLog
OLDSTRINGIDCLASS_	原STRINGIDCLASS值，对应HibernateStringUpdateLog
OLDSTRINGIDVALUE_	原STRINGID值，对应HibernateStringUpdateLog
NEWSTRINGIDCLASS_	新STRINGIDCLASS值，对应HibernateStringUpdateLog
NEWSTRINGIDVALUE_	新STRINGID值，对应HibernateStringUpdateLog
OLDLONGVALUE_	原LONG值，对应LongUpdateLog
NEWLONGVALUE_	新LONG值，对应LongUpdateLog
OLDSTRINGVALUE_	原STRING值，对应StringUpdateLog
NEWSTRINGVALUE_	新STRING值，对应StringUpdateLog
TASKINSTANCE_	日志所属的TASKINSTANCE，对应TaskLog TaskCreateLog TaskAssignLog TaskEndLog
TASKACTORID_	任务的新ACTORID，对应TaskAssignLog TaskCreateLog SwimlaneCreateLog SwimlaneAssignLog
TASKOLDACTORID_	任务的原ACTORID，对应TaskAssignLog SwimlaneAssignLog
SWIMLANEINSTANCE_	日志所属的SWIMLANEINSTANC，对应SwimlaneLog SwimlaneCreateLog SwimlaneAssignLog

2.4 JBPM_RUNTIMEACTION：流程实时ACTION表

字段名	字段含义	主键	外键
ID_	标识	√
VERSION_	版本
EVENTTYPE_	实时ACTION所处的事件类型名称
TYPE_	实时ACTION所在的图形节点类型 "A" ：Task "C" ：ProcessState "D" ：Decision" "E" ：EndState" "F" ：Fork" "J" ：Join" "K" ：TaskNode" "N" ：Node" "P" ：ProcessDefinition" "R" ：StartState" "S" ：State" "T" ：Transition" "U" ：SuperState"
GRAPHELEMENT_	实时ACTION所在的图形节点的ID
PROCESSINSTANCE_	实时ACTION所在的流程实例，对应JBPM_PROCESSINSTANCE
ACTION_	实时ACTION对应的ACTION，对应JBPM_ACTION
PROCESSINSTANCEINDEX_	？

2.5 JBPM_VARIABLEINSTANCE：流程变量实例表

字段名	字段含义	主键	外键
ID_	标识
CLASS_	变量类型： V : org.jbpm.context.exe.VariableInstance B : org.jbpm.context.exe.variableinstance.ByteArrayInstance D : org.jbpm.context.exe.variableinstance.DateInstance O : org.jbpm.context.exe.variableinstance.DoubleInstance H : org.jbpm.context.exe.variableinstance.HibernateLongInstance I : org.jbpm.context.exe.variableinstance.HibernateStringInstance L : org.jbpm.context.exe.variableinstance.LongInstance S : org.jbpm.context.exe.variableinstance.StringInstance N : org.jbpm.context.exe.variableinstance.NullInstance
NAME_	变量名称
TYPE_	？
CONVERTER_	数值转换器
TOKEN_	变量所在的TOKEN，对应JBPM_TOKEN		√
TOKENVARIABLEMAP_	该变量所属的TOKEN的变量映射，对应JBPM_TOKENVARIABLEMAP		√
PROCESSINSTANCEINDEX_	？
PROCESSINSTANCE_	变量所在的流程实例，对应JBPM_PROCESSINSTANCE		√
BYTEARRAYVALUE_	当流程变量是ByteArray类型时，变量的值，对应JBPM_BYTEARRAY
DATEVALUE_	当流程变量是DATE类型时，变量的值
DOUBLEVALUE_	当流程变量是DOUBLE类型时，变量的值
LONGIDCLASS_	当流程变量是了HibernateLongInstance类型时，变量的类型
LONGVALUE_	当流程变量是了HibernateLongInstance/Long类型时，变量的值
STRINGIDCLASS_	当流程变量是了HibernateStringInstance类型时，变量的类型
STRINGVALUE_	当流程变量是了HibernateStringInstance/String类型时，变量的值
TASKINSTANCE_	变量所在的任务实例，对应JBPM_TASKINSTANCE

2.6 JBPM_COMMENT：流程备注信息表

字段名	字段含义	主键	外键
ID_	标识	√
VERSION_	版本
ACTORID_	产生该备注的ACTOR
TIME_	流程备注产生时间
MESSAGE_	流程备注信息
TOKEN_	流程备注所属的TOKEN，对应JBPM_TOKEN		√
TASKINSTANCE_	流程备注所属的TASKINSTANCE，对应JBPM_TASKINSTANCE		√
TOKENINDEX_	？		√
TASKINSTANCEINDEX_	？

2.7 JBPM_MESSAGE：流程异步消息表

字段名	字段含义	主键	外键
ID_	标识	√
CLASS_	消息类型 M : org.jbpm.msg.Message T : org.jbpm.msg.db.TextMessage A : org.jbpm.command.ExecuteActionCommand N : org.jbpm.command.ExecuteNodeCommand S : org.jbpm.command.SignalCommand K : org.jbpm.command.TaskInstanceEndCommand
DESTINATION_	消息目的源
EXCEPTION_	消息异常信息
ISSUSPENDED_	？
TOKEN_	流程消息所属的TOKEN，对应JBPM_TOKEN		√
TASKINSTANCE_	流程消息所属的TASKINSTANCE，对应JBPM_TASKINSTANCE		√
TEXT_	消息内容
ACTION_	流程消息所属的ACTION，对应JBPM_ ACTION		√
NODE_	流程消息所属的NODE，对应JBPM_ NODE		√
TRANSITIONNAME_	？

2.8 JBPM_TIMER：流程定时器表

字段名	字段含义	主键	外键
ID_	标识	√
NAME_	定时器名称
DUEDATE_	定时器每次执行的间隔时间
REPEAT_	定时器是否重复执行
TRANSITIONNAME_	定时器执行后，流程的目的TRANSITION名称
EXCEPTION_	流程备注所属的TOKEN，对应JBPM_TOKEN
ISSUSPENDED_
ACTION_	定时器所属的ACTION，对应JBPM_ ACTION		√
TOKEN_	定时器所属的TOKEN，对应JBPM_ TOKEN		√
PROCESSINSTANCE_	定时器所属的PROCESSINSTANCE，对应JBPM_PROCESSINSTANCE		√
TASKINSTANCE_	定时器所属的TASKINSTANCE，对应JBPM_TASKINSTANCE		√
GRAPHELEMENTTYPE_	定时器所属的图形元素类型
GRAPHELEMENT_	定时器所属的图形元素

2.9 JBPM_TOKENVARIABLEMAP：流程TOKEN变量MAP表

字段名	字段含义	主键	外键
ID_	标识	√
TOKEN_	流程TOKEN变量映射所属的TOKEN，对应JBPM_TOKEN		√
CONTEXTINSTANCE_	流程TOKEN变量映射所属的流程上下文实例，对应JBPM_MODULEINSTANCE		√

2.10 JBPM_MODULEINSTANCE：流程模块实例表

字段名	字段含义	主键	外键
ID_	标识	√
CLASS_	模块实例类型： M: org.jbpm.module.exe.ModuleInstance C: org.jbpm.context.exe.ContextInstance L: org.jbpm.logging.exe.LoggingInstance I: org.jbpm.scheduler.exe.SchedulerInstanceT: org.jbpm.taskmgmt.def.TaskMgmtDefinition
PROCESSINSTANCE_	模块实例所属的流程实例，对应JBPM_PROCESSINSTANCE		√
TASKMGMTDEFINITION_	任务类模块实例所属的任务模块，对应JBPM_MODULEDEFINITION		√
NAME_	模块实例名称

2.11 JBPM_BYTEARRAY：文件模块形式的流程变量实例表

字段名	字段含义	主键	外键
ID_	标识
NAME_	流程变量名称
FILEDEFINITION_	FILEMODULE，对应JBPM_MODULEDEFINITION		√

2.12 JBPM_BYTEBLOCK：

字段名	字段含义	主键	外键
PROCESSFILE_	对应JBPM_BYTEARRAY		√
BYTES_	序列化流程变量
INDEX_	标识		√

补：JBPM_TASKINSTANCE：

字段名	字段含义	主键	外键
ID_	标识	√
CLASS_
VERSION_
NAME_
DISCRIPTION
ACTORID_
CREATE_
START_
END_
DUEDATE_
PRIORITY_
ISCANCELLED_
ISSUSPENDED_
ISOPEN_
ISSIGNALLING_
ISBLOCKING_
TASK_
TOKEN_
PROCINST_
SWIMLANINSTANCE_
TASKMGMTINSTANCE_

这哥们太帅了，他的博客也不错，推荐大家没事去逛逛
附上转载地址http://www.blogjava.net/libin2722/articles/143249.html

本文链接

7-1

2010-07-12T06:56:00Z

/*
* ReadWrit.h
*
* Sample code for Multithreading Applications in Win32
* This is from Chapter 7, Listing 7-1
*
* Demonstrates an implementation of the
* Readers/Writers algorithm. This version
* gives preference to readers.
*/

///////////////////////////////////////////////////////

//
// Structure definition
//

typedef struct _RWLock
{
    // Handle to a mutex that allows
    // a single reader at a time access
    // to the reader counter.
    HANDLE    hMutex;

    // Handle to a semaphore that keeps
    // the data locked for either the
    // readers or the writers.
    HANDLE    hDataLock;

    // The count of the number of readers.
    // Can legally be zero or one while
    // a writer has the data locked.
    int        nReaderCount;
} RWLock;

//
// Reader/Writer prototypes
//

BOOL InitRWLock(RWLock *pLock);
BOOL DestroyRWLock(RWLock *pLock);
BOOL AcquireReadLock(RWLock *pLock);
int ReleaseReadLock(RWLock *pLock);
BOOL AcquireWriteLock(RWLock *pLock);
int ReleaseWriteLock(RWLock *pLock);
BOOL ReadOK(RWLock *pLock);
BOOL WriteOK(RWLock *pLock);

BOOL FatalError(char *s);

/*
* ReadWrit.c
*
* Sample code for "Multithreading Applications in Win32"
* This is from Chapter 7, various listings.
*
* Demonstrates an implementation of the
* Readers/Writers algorithm. This version
* gives preference to readers.
*/

#define WIN32_LEAN_AND_MEAN
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include "ReadWrit.h"

// If we wait more than 2 seconds, then something is probably wrong!
#define MAXIMUM_TIMEOUT 2000

// Here's the pseudocode for what is going on:
//
// Lock for Reader:
//  Lock the mutex
//  Bump the count of readers
//  If this is the first reader, lock the data
//  Release the mutex
//
// Unlock for Reader:
//  Lock the mutex
//  Decrement the count of readers
//  If this is the last reader, unlock the data
//  Release the mutex
//
// Lock for Writer:
//  Lock the data
//
// Unlock for Reader:
//  Unlock the data

///////////////////////////////////////////////////////

BOOL MyWaitForSingleObject(HANDLE hObject)
{
    DWORD result;

    result = WaitForSingleObject(hObject, MAXIMUM_TIMEOUT);
    // Comment this out if you want this to be non-fatal
    if (result != WAIT_OBJECT_0)
        FatalError("MyWaitForSingleObject - Wait failed, you probably forgot to call release!");
    return (result == WAIT_OBJECT_0);
}

BOOL InitRWLock(RWLock *pLock)
{
    pLock->nReaderCount = 0;
    pLock->hDataLock = CreateSemaphore(NULL, 1, 1, NULL);
    if (pLock->hDataLock == NULL)
        return FALSE;
    pLock->hMutex = CreateMutex(NULL, FALSE, NULL);
    if (pLock->hMutex == NULL)
    {
        CloseHandle(pLock->hDataLock);
        return FALSE;
    }
    return TRUE;
}

BOOL DestroyRWLock(RWLock *pLock)
{
    DWORD result = WaitForSingleObject(pLock->hDataLock, 0);
    if (result == WAIT_TIMEOUT)
        return FatalError("DestroyRWLock - Can't destroy object, it's locked!");

    CloseHandle(pLock->hMutex);
    CloseHandle(pLock->hDataLock);
    return TRUE;
}

BOOL AcquireReadLock(RWLock *pLock)
{
    BOOL result = TRUE;

    if (!MyWaitForSingleObject(pLock->hMutex))
        return FALSE;

    if(++pLock->nReaderCount == 1)
        result = MyWaitForSingleObject(pLock->hDataLock);

    ReleaseMutex(pLock->hMutex);
    return result;
}

BOOL ReleaseReadLock(RWLock *pLock)
{
    int result;
    LONG lPrevCount;

    if (!MyWaitForSingleObject(pLock->hMutex))
        return FALSE;

    if (--pLock->nReaderCount == 0)
        result = ReleaseSemaphore(pLock->hDataLock, 1, &lPrevCount);

    ReleaseMutex(pLock->hMutex);
    return result;
}

BOOL AcquireWriteLock(RWLock *pLock)
{
    return MyWaitForSingleObject(pLock->hDataLock);
}

BOOL ReleaseWriteLock(RWLock *pLock)
{
    int result;
    LONG lPrevCount;

    result = ReleaseSemaphore(pLock->hDataLock, 1, &lPrevCount);
    if (lPrevCount != 0)
        FatalError("ReleaseWriteLock - Semaphore was not locked!");
    return result;
}

BOOL ReadOK(RWLock *pLock)
{
    // This check is not perfect, because we
    // do not know for sure if we are one of
    // the readers.
    return (pLock->nReaderCount > 0);
}

BOOL WriteOK(RWLock *pLock)
{
    DWORD result;

    // The first reader may be waiting in the mutex,
    // but any more than that is an error.
    if (pLock->nReaderCount > 1)
        return FALSE;

    // This check is not perfect, because we
    // do not know for sure if this thread was
    // the one that had the semaphore locked.
    result = WaitForSingleObject(pLock->hDataLock, 0);
    if (result == WAIT_TIMEOUT)
        return TRUE;

    // a count is kept, which was incremented in Wait.
    result = ReleaseSemaphore(pLock->hDataLock, 1, NULL);
    if (result == FALSE)
        FatalError("WriteOK - ReleaseSemaphore failed");
    return FALSE;
}

///////////////////////////////////////////////////////

/*
* Error handler
*/
BOOL FatalError(char *s)
{
    fprintf(stdout, "%s\n", s);
    // Comment out exit() to prevent termination
    exit(EXIT_FAILURE);
    return FALSE;
}

/*
* List.c
*
* Sample code for "Multithreading Applications in Win32"
* This is from Chapter 7, Listing 7-1
*
* Demonstrates an implementation of the
* Readers/Writers algorithm. This version
* gives preference to readers.
*/

#define WIN32_LEAN_AND_MEAN
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include "ReadWrit.h"

///////////////////////////////////////////////////////

//
// Structure definition
//

typedef struct _Node
{
    struct _Node *pNext;
    char    szBuffer[80];
} Node;

typedef struct _List
{
    RWLock    lock;
    Node    *pHead;
} List;

//
// Linked list prototypes
//

BOOL InitRWLock(RWLock *pLock);
BOOL DeleteList(List *pList);
BOOL AddHead(List *pList, Node *node);
BOOL DeleteHead(List *pList);
BOOL Insert(List *pList, Node *afterNode, Node *newNode);
Node *Next(List *pList, Node *node);

//
// Test functions prototypes
//

DWORD WINAPI LoadThreadFunc(LPVOID n);
DWORD WINAPI SearchThreadFunc(LPVOID n);
DWORD WINAPI DeleteThreadFunc(LPVOID n);

//
// Global variables
//

// This is the list we use for testing
List *gpList;

///////////////////////////////////////////////////////

List *CreateList()
{
    List *pList = GlobalAlloc(GPTR, sizeof(List));
    if (InitRWLock(&pList->lock) == FALSE)
    {
        GlobalFree(pList);
        pList = NULL;
    }
    return pList;
}

BOOL DeleteList(List *pList)
{
    AcquireWriteLock(&pList->lock);
    while (DeleteHead(pList))
        ;
    ReleaseWriteLock(&pList->lock);

    DestroyRWLock(&gpList->lock);

    GlobalFree(pList);

    return TRUE;
}

BOOL AddHead(List *pList, Node *pNode)
{
    if (!WriteOK(&pList->lock))
        return FatalError("AddHead - not allowed to write!");

    pNode->pNext = pList->pHead;
    pList->pHead = pNode;
}

BOOL DeleteHead(List *pList)
{
    Node *pNode;

    if (!WriteOK(&pList->lock))
        return FatalError("AddHead - not allowed to write!");

    if (pList->pHead == NULL)
        return FALSE;

    pNode = pList->pHead->pNext;
    GlobalFree(pList->pHead);
    pList->pHead = pNode;
    return TRUE;
}

BOOL Insert(List *pList, Node *afterNode, Node *newNode)
{
    if (!WriteOK(&pList->lock))
        return FatalError("Insert - not allowed to write!");

    if (afterNode == NULL)
    {
        AddHead(pList, newNode);
    }
    else
    {
        newNode->pNext = afterNode->pNext;
        afterNode->pNext = newNode;
    }
}

Node *Next(List *pList, Node *pNode)
{
    if (!ReadOK(&pList->lock))
    {
        FatalError("Next - Not allowed to read!");
        return NULL;
    }

    if (pNode == NULL)
        return pList->pHead;
    else
        return pNode->pNext;
}

///////////////////////////////////////////////////////

DWORD WINAPI ThreadFunc(LPVOID);

int main()
{
    HANDLE  hThrds[4];
    int     slot = 0;
    int        rc;
    int        nThreadCount = 0;
    DWORD    dwThreadId;

    gpList = CreateList();
    if (!gpList)
        FatalError("main - List creation failed!");

    hThrds[nThreadCount++] = CreateThread(NULL,
        0, LoadThreadFunc, 0, 0, &dwThreadId );

    hThrds[nThreadCount++] = CreateThread(NULL,
        0, SearchThreadFunc, (LPVOID)"pNode", 0, &dwThreadId );

    hThrds[nThreadCount++] = CreateThread(NULL,
        0, SearchThreadFunc, (LPVOID)"pList", 0, &dwThreadId );

    hThrds[nThreadCount++] = CreateThread(NULL,
        0, DeleteThreadFunc, 0, 0, &dwThreadId );

    /* Now wait for all threads to terminate */
    rc = WaitForMultipleObjects(
        nThreadCount,
        hThrds,
        TRUE,
        INFINITE );

    for (slot=0; slot<nThreadCount; slot++)
        CloseHandle(hThrds[slot]);
    printf("\nProgram finished.\n");

    DeleteList(gpList);

    return EXIT_SUCCESS;
}

/*
* Slowly load the contents of "List.c" into the
* linked list.
*/
DWORD WINAPI LoadThreadFunc(LPVOID n)
{
    int nBatchCount;
    Node *pNode;

    FILE* fp = fopen("List.c", "r");
    if (!fp)
    {
        fprintf(stderr, "ReadWrit.c not found\n");
        exit(EXIT_FAILURE);
    }

    pNode = GlobalAlloc(GPTR, sizeof(Node));
    nBatchCount = (rand() % 10) + 2;
    AcquireWriteLock(&gpList->lock);

    while (fgets(pNode->szBuffer, sizeof(Node), fp))
    {
        AddHead(gpList, pNode);

        // Try not to hog the lock
        if (--nBatchCount == 0)
        {
            ReleaseWriteLock(&gpList->lock);
            Sleep(rand() % 5);
            nBatchCount = (rand() % 10) + 2;
            AcquireWriteLock(&gpList->lock);
        }
        pNode = GlobalAlloc(GPTR, sizeof(Node));
    }

    ReleaseWriteLock(&gpList->lock);
    return 0;
}

/*
* Every so often, walked the linked list
* and figure out how many lines one string
* appears (given as the startup param)
*/
DWORD WINAPI SearchThreadFunc(LPVOID n)
{
    int i;
    char *szSearch = (char *)n;

    for (i=0; i<20; i++)
    {
        int        nFoundCount = 0;
        Node   *next = NULL;

        AcquireReadLock(&gpList->lock);
        next = Next(gpList, next);
        while (next)
        {
            if (strstr(next->szBuffer, szSearch))
                nFoundCount++;
            next = Next(gpList, next);
        }

        ReleaseReadLock(&gpList->lock);

        printf("Found %d lines with '%s'\n", nFoundCount, szSearch);
        Sleep((rand() % 30));
    }
    return 0;
}

/*
* Every so often, delete some entries in the list.
*/
DWORD WINAPI DeleteThreadFunc(LPVOID n)
{
    int i;

    for (i=0; i<100; i++)
    {
        Sleep(1);
        AcquireWriteLock(&gpList->lock);
        DeleteHead(gpList);
        DeleteHead(gpList);
        DeleteHead(gpList);
        ReleaseWriteLock(&gpList->lock);
    }

    return 0;
}

本文链接

6-3

2010-07-09T07:03:00Z

/*
* IoByAPC.c
*
* Sample code for Multithreading Applications in Win32
* This is from Chapter 6, Listing 6-3
*
* Demonstrates how to use APC's (asynchronous
* procedure calls) instead of signaled objects
* to service multiple outstanding overlapped
* operations on a file.
*/

#define WIN32_LEAN_AND_MEAN
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include "MtVerify.h"

//
// Constants
//
#define MAX_REQUESTS    5
#define READ_SIZE       512
#define MAX_TRY_COUNT   5

//
// Function prototypes
//
void CheckOsVersion();
int QueueRequest(int nIndex, DWORD dwLocation, DWORD dwAmount);

//
// Global variables
//

// Need a single event object so we know when all I/O is finished
HANDLE ghEvent;
// Keep track of each individual I/O operation
OVERLAPPED gOverlapped[MAX_REQUESTS];
// Handle to the file of interest.
HANDLE ghFile;
// Need a place to put all this data
char gBuffers[MAX_REQUESTS][READ_SIZE];
int nCompletionCount;

/*
* I/O Completion routine gets called
* when app is alertable (in WaitForSingleObjectEx)
* and an overlapped I/O operation has completed.
*/
VOID WINAPI FileIOCompletionRoutine(
    DWORD dwErrorCode, // completion code
    DWORD dwNumberOfBytesTransfered,    // number of bytes transferred
    LPOVERLAPPED lpOverlapped   // pointer to structure with I/O information
   )
{
    // The event handle is really the user defined data
    int nIndex = (int)(lpOverlapped->hEvent);
    printf("Read #%d returned %d. %d bytes were read.\n",
        nIndex,
        dwErrorCode,
        dwNumberOfBytesTransfered);

if (++nCompletionCount == MAX_REQUESTS)
SetEvent(ghEvent); // Cause the wait to terminate
}

int main()
{
int i;
char szPath[MAX_PATH];

CheckOsVersion();

    // Need to know when to stop
    MTVERIFY(
        ghEvent = CreateEvent(
                     NULL,    // No security
                     TRUE,    // Manual reset - extremely important!
                     FALSE,   // Initially set Event to non-signaled state
                     NULL     // No name
                    )
    );

    GetWindowsDirectory(szPath, sizeof(szPath));
    strcat(szPath, "http://www.cnblogs.com/nanshouyong326/admin/file://WINHLP32.EXE/");
    // Open the file for overlapped reads
    ghFile = CreateFile( szPath,
                    GENERIC_READ,
                    FILE_SHARE_READ|FILE_SHARE_WRITE,
                    NULL,
                    OPEN_EXISTING,
                    FILE_FLAG_OVERLAPPED,
                    NULL
                );
    if (ghFile == INVALID_HANDLE_VALUE)
    {
        printf("Could not open %s\n", szPath);
        return -1;
    }

    // Queue up a few requests
    for (i=0; i<MAX_REQUESTS; i++)
    {
        // Read some bytes every few K
        QueueRequest(i, i*16384, READ_SIZE);
    }

printf("QUEUED!!\n");

    // Wait for all the operations to complete.
    for (;;)
    {
        DWORD rc;
        rc = WaitForSingleObjectEx(ghEvent, INFINITE, TRUE );
        if (rc == WAIT_OBJECT_0)
            break;
        MTVERIFY(rc == WAIT_IO_COMPLETION);
    }

CloseHandle(ghFile);

return EXIT_SUCCESS;
}

/*
* Call ReadFileEx to start an overlapped request.
* Make sure we handle errors that are recoverable.
*/
int QueueRequest(int nIndex, DWORD dwLocation, DWORD dwAmount)
{
    int i;
    BOOL rc;
    DWORD err;

gOverlapped[nIndex].hEvent = (HANDLE)nIndex;
gOverlapped[nIndex].Offset = dwLocation;

    for (i=0; i<MAX_TRY_COUNT; i++)
    {
        rc = ReadFileEx(
            ghFile,
            gBuffers[nIndex],
            dwAmount,
            &gOverlapped[nIndex],
            FileIOCompletionRoutine
        );

        // Handle success
        if (rc)
        {
            // asynchronous i/o is still in progress
            printf("Read #%d queued for overlapped I/O.\n", nIndex);
            return TRUE;
        }

err = GetLastError();

        // Handle recoverable error
        if ( err == ERROR_INVALID_USER_BUFFER ||
             err == ERROR_NOT_ENOUGH_QUOTA ||
             err == ERROR_NOT_ENOUGH_MEMORY )
        {
            Sleep(50); // Wait around and try later
            continue;
        }

        // Give up on fatal error.
        break;
    }

printf("ReadFileEx failed.\n");
return -1;
}

//
// Make sure we are running under an operating
// system that supports overlapped I/O to files.
//
void CheckOsVersion()
{
OSVERSIONINFO ver;
BOOL bResult;

ver.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);

bResult = GetVersionEx((LPOSVERSIONINFO) &ver);

    if ( (!bResult) ||
         (ver.dwPlatformId != VER_PLATFORM_WIN32_NT) )
    {
        fprintf(stderr, "IoByAPC must be run under Windows NT.\n");
  exit(EXIT_FAILURE);
    }

}

00401040 /$ 81EC 0C020000 sub     esp, 20C
00401046 |. 56            push    esi
00401047 |. 57            push    edi
00401048 |. E8 E3020000   call    00401330
0040104D |. 6A 00         push    0                                ; /EventName = NULL
0040104F |. 6A 00         push    0                                ; |InitiallySignaled = FALSE
00401051 |. 6A 01         push    1                                ; |ManualReset = TRUE
00401053 |. 6A 00         push    0                                ; |pSecurity = NULL
00401055 |. FF15 28204000 call    dword ptr [<&KERNEL32.CreateEven>; \CreateEventA
0040105B |. 85C0          test    eax, eax
0040105D |. A3 90314000   mov     dword ptr [403190], eax
00401062 |. 0F85 80000000 jnz     004010E8
00401068 |. FF15 24204000 call    dword ptr [<&KERNEL32.GetLastErr>; [GetLastError
0040106E |. 6A 00         push    0                                ; /Arguments = NULL
00401070 |. 8D4C24 0C     lea     ecx, dword ptr [esp+C]           ; |
00401074 |. 6A 00         push    0                                ; |BufSize = 0
00401076 |. 51            push    ecx                              ; |Buffer
00401077 |. 6A 00         push    0                                ; |LanguageId = 0 (LANG_NEUTRAL)
00401079 |. 50            push    eax                              ; |MessageId
0040107A |. 6A 00         push    0                                ; |pSource = NULL
0040107C |. 68 00110000   push    1100                             ; |Flags = ALLOCATE_BUFFER|FROM_SYSTEM|0
00401081 |. FF15 20204000 call    dword ptr [<&KERNEL32.FormatMess>; \FormatMessageA
00401087 |. 8B5424 08     mov     edx, dword ptr [esp+8]
0040108B |. 8D4424 10     lea     eax, dword ptr [esp+10]
0040108F |. 52            push    edx                              ; /<%s>
00401090 |. 68 D8304000   push    004030D8                         ; |<%s> = "ghEvent = CreateEvent( NULL, TRUE, FALSE, NULL )"
00401095 |. 68 CC304000   push    004030CC                         ; |<%s> = "IoByAPC.c"
0040109A |. 6A 55         push    55                               ; |<%d> = 55 (85.)
0040109C |. 68 88304000   push    00403088                         ; |Format = LF,"The following call failed at line %d in %s:",LF,LF,"    %s",LF,LF,"Reason: %s",LF,""
004010A1 |. 50            push    eax                              ; |s
004010A2 |. FF15 7C204000 call    dword ptr [<&USER32.wsprintfA>] ; \wsprintfA
004010A8 |. 83C4 18       add     esp, 18
004010AB |. 8D4C24 0C     lea     ecx, dword ptr [esp+C]
004010AF |. 8D7C24 10     lea     edi, dword ptr [esp+10]
004010B3 |. 33C0          xor     eax, eax
004010B5 |. 6A 00         push    0                                ; /pOverlapped = NULL
004010B7 |. 51            push    ecx                              ; |pBytesWritten
004010B8 |. 83C9 FF       or      ecx, FFFFFFFF                    ; |
004010BB |. 8D5424 18     lea     edx, dword ptr [esp+18]          ; |
004010BF |. F2:AE         repne   scas byte ptr es:[edi]           ; |
004010C1 |. F7D1          not     ecx                              ; |
004010C3 |. 49            dec     ecx                              ; |
004010C4 |. 51            push    ecx                              ; |nBytesToWrite
004010C5 |. 52            push    edx                              ; |Buffer
004010C6 |. 6A F4         push    -0C                              ; |/DevType = STD_ERROR_HANDLE
004010C8 |. FF15 1C204000 call    dword ptr [<&KERNEL32.GetStdHand>; |\GetStdHandle
004010CE |. 50            push    eax                              ; |hFile
004010CF |. FF15 18204000 call    dword ptr [<&KERNEL32.WriteFile>>; \WriteFile
004010D5 |. 68 B80B0000   push    0BB8                             ; /Timeout = 3000. ms
004010DA |. FF15 14204000 call    dword ptr [<&KERNEL32.Sleep>]    ; \Sleep
004010E0 |. 6A 01         push    1                                ; /status = 1
004010E2 |. FF15 40204000 call    dword ptr [<&MSVCRTD.exit>]      ; \exit
004010E8 |> 53            push    ebx
004010E9 |. 8D8424 140100>lea     eax, dword ptr [esp+114]
004010F0 |. 68 04010000   push    104                              ; /BufSize = 104 (260.)
004010F5 |. 50            push    eax                              ; |Buffer
004010F6 |. FF15 10204000 call    dword ptr [<&KERNEL32.GetWindows>; \GetWindowsDirectoryA
004010FC |. BF 78304000   mov     edi, 00403078                    ; ASCII "\WINHLP32.EXE"
00401101 |. 83C9 FF       or      ecx, FFFFFFFF
00401104 |. 33C0          xor     eax, eax
00401106 |. 8D9424 140100>lea     edx, dword ptr [esp+114]
0040110D |. F2:AE         repne   scas byte ptr es:[edi]
0040110F |. F7D1          not     ecx
00401111 |. 2BF9          sub     edi, ecx
00401113 |. 50            push    eax                              ; /hTemplateFile => NULL
00401114 |. 8BF7          mov     esi, edi                         ; |
00401116 |. 8BD9          mov     ebx, ecx                         ; |
00401118 |. 8BFA          mov     edi, edx                         ; |
0040111A |. 83C9 FF       or      ecx, FFFFFFFF                    ; |
0040111D |. F2:AE         repne   scas byte ptr es:[edi]           ; |
0040111F |. 8BCB          mov     ecx, ebx                         ; |
00401121 |. 4F            dec     edi                              ; |
00401122 |. C1E9 02       shr     ecx, 2                           ; |
00401125 |. F3:A5         rep     movs dword ptr es:[edi], dword p>; |
00401127 |. 68 00000040   push    40000000                         ; |Attributes = OVERLAPPED
0040112C |. 8BCB          mov     ecx, ebx                         ; |
0040112E |. 6A 03         push    3                                ; |Mode = OPEN_EXISTING
00401130 |. 50            push    eax                              ; |pSecurity => NULL
00401131 |. 83E1 03       and     ecx, 3                           ; |
00401134 |. 6A 03         push    3                                ; |ShareMode = FILE_SHARE_READ|FILE_SHARE_WRITE
00401136 |. 8D8424 280100>lea     eax, dword ptr [esp+128]         ; |
0040113D |. 68 00000080   push    80000000                         ; |Access = GENERIC_READ
00401142 |. F3:A4         rep     movs byte ptr es:[edi], byte ptr>; |
00401144 |. 50            push    eax                              ; |FileName
00401145 |. FF15 0C204000 call    dword ptr [<&KERNEL32.CreateFile>; \CreateFileA
0040114B |. 83F8 FF       cmp     eax, -1
0040114E |. A3 94314000   mov     dword ptr [403194], eax
00401153 |. 5B            pop     ebx
00401154 |. 75 22         jnz     short 00401178
00401156 |. 8D8C24 100100>lea     ecx, dword ptr [esp+110]
0040115D |. 51            push    ecx                              ; /<%s>
0040115E |. 68 64304000   push    00403064                         ; |format = "Could not open %s",LF,""
00401163 |. FF15 3C204000 call    dword ptr [<&MSVCRTD.printf>]    ; \printf
00401169 |. 83C4 08       add     esp, 8
0040116C |. 83C8 FF       or      eax, FFFFFFFF
0040116F |. 5F            pop     edi
00401170 |. 5E            pop     esi
00401171 |. 81C4 0C020000 add     esp, 20C
00401177 |. C3            retn
00401178 |> 33FF          xor     edi, edi
0040117A |. 33F6          xor     esi, esi
0040117C |> 68 00020000   /push    200
00401181 |. 56            |push    esi
00401182 |. 57            |push    edi
00401183 |. E8 E8000000   |call    00401270
00401188 |. 83C4 0C       |add     esp, 0C
0040118B |. 81C6 00400000 |add     esi, 4000
00401191 |. 47            |inc     edi
00401192 |. 81FE 00400100 |cmp     esi, 14000
00401198 |.^ 72 E2         \jb      short 0040117C
0040119A |. 68 58304000   push    00403058                         ; /format = "QUEUED!!",LF,""
0040119F |. FF15 3C204000 call    dword ptr [<&MSVCRTD.printf>]    ; \printf
004011A5 |. 8B15 90314000 mov     edx, dword ptr [403190]
004011AB |. 8B35 08204000 mov     esi, dword ptr [<&KERNEL32.WaitF>; kernel32.WaitForSingleObjectEx
004011B1 |. 83C4 04       add     esp, 4
004011B4 |. 6A 01         push    1                                ; /fAlertable = TRUE
004011B6 |. 6A FF         push    -1                               ; |Timeout = INFINITE
004011B8 |. 52            push    edx                              ; |hObject => NULL
004011B9 |. FFD6          call    esi                              ; \WaitForSingleObjectEx
004011BB |. 85C0          test    eax, eax
004011BD |. 74 17         je      short 004011D6
004011BF |> 3D C0000000   /cmp     eax, 0C0
004011C4 |. 75 28         |jnz     short 004011EE
004011C6 |. A1 90314000   |mov     eax, dword ptr [403190]
004011CB |. 6A 01         |push    1
004011CD |. 6A FF         |push    -1
004011CF |. 50            |push    eax
004011D0 |. FFD6          |call    esi
004011D2 |. 85C0          |test    eax, eax
004011D4 |.^ 75 E9         \jnz     short 004011BF
004011D6 |> 8B0D 94314000 mov     ecx, dword ptr [403194]
004011DC |. 51            push    ecx                              ; /hObject => NULL
004011DD |. FF15 04204000 call    dword ptr [<&KERNEL32.CloseHandl>; \CloseHandle
004011E3 |. 5F            pop     edi
004011E4 |. 33C0          xor     eax, eax
004011E6 |. 5E            pop     esi
004011E7 |. 81C4 0C020000 add     esp, 20C
004011ED |. C3            retn
004011EE |> FF15 24204000 call    dword ptr [<&KERNEL32.GetLastErr>; [GetLastError
004011F4 |. 6A 00         push    0                                ; /Arguments = NULL
004011F6 |. 8D5424 0C     lea     edx, dword ptr [esp+C]           ; |
004011FA |. 6A 00         push    0                                ; |BufSize = 0
004011FC |. 52            push    edx                              ; |Buffer
004011FD |. 6A 00         push    0                                ; |LanguageId = 0 (LANG_NEUTRAL)
004011FF |. 50            push    eax                              ; |MessageId
00401200 |. 6A 00         push    0                                ; |pSource = NULL
00401202 |. 68 00110000   push    1100                             ; |Flags = ALLOCATE_BUFFER|FROM_SYSTEM|0
00401207 |. FF15 20204000 call    dword ptr [<&KERNEL32.FormatMess>; \FormatMessageA
0040120D |. 8B4424 08     mov     eax, dword ptr [esp+8]
00401211 |. 8D4C24 10     lea     ecx, dword ptr [esp+10]
00401215 |. 50            push    eax                              ; /<%s>
00401216 |. 68 3C304000   push    0040303C                         ; |<%s> = "rc == WAIT_IO_COMPLETION"
0040121B |. 68 CC304000   push    004030CC                         ; |<%s> = "IoByAPC.c"
00401220 |. 6A 78         push    78                               ; |<%d> = 78 (120.)
00401222 |. 68 88304000   push    00403088                         ; |Format = LF,"The following call failed at line %d in %s:",LF,LF,"    %s",LF,LF,"Reason: %s",LF,""
00401227 |. 51            push    ecx                              ; |s
00401228 |. FF15 7C204000 call    dword ptr [<&USER32.wsprintfA>] ; \wsprintfA
0040122E |. 8D7C24 28     lea     edi, dword ptr [esp+28]
00401232 |. 83C9 FF       or      ecx, FFFFFFFF
00401235 |. 33C0          xor     eax, eax
00401237 |. 83C4 18       add     esp, 18
0040123A |. F2:AE         repne   scas byte ptr es:[edi]
0040123C |. F7D1          not     ecx
0040123E |. 8D5424 0C     lea     edx, dword ptr [esp+C]
00401242 |. 6A 00         push    0                                ; /pOverlapped = NULL
00401244 |. 49            dec     ecx                              ; |
00401245 |. 52            push    edx                              ; |pBytesWritten
00401246 |. 8D4424 18     lea     eax, dword ptr [esp+18]          ; |
0040124A |. 51            push    ecx                              ; |nBytesToWrite
0040124B |. 50            push    eax                              ; |Buffer
0040124C |. 6A F4         push    -0C                              ; |/DevType = STD_ERROR_HANDLE
0040124E |. FF15 1C204000 call    dword ptr [<&KERNEL32.GetStdHand>; |\GetStdHandle
00401254 |. 50            push    eax                              ; |hFile
00401255 |. FF15 18204000 call    dword ptr [<&KERNEL32.WriteFile>>; \WriteFile
0040125B |. 68 B80B0000   push    0BB8                             ; /Timeout = 3000. ms
00401260 |. FF15 14204000 call    dword ptr [<&KERNEL32.Sleep>]    ; \Sleep
00401266 |. 6A 01         push    1                                ; /status = 1
00401268 |. FF15 40204000 call    dword ptr [<&MSVCRTD.exit>]      ; \exit
0040126E |. 90            nop
0040126F |. 90            nop
00401270 |$ 53            push    ebx
00401271 |. 55            push    ebp
00401272 |. 56            push    esi
00401273 |. 57            push    edi
00401274 |. 8B7C24 14     mov     edi, dword ptr [esp+14]
00401278 |. 8B4C24 18     mov     ecx, dword ptr [esp+18]
0040127C |. 8B5C24 1C     mov     ebx, dword ptr [esp+1C]
00401280 |. 8B2D 2C204000 mov     ebp, dword ptr [<&KERNEL32.ReadF>; kernel32.ReadFileEx
00401286 |. 8D04BF        lea     eax, dword ptr [edi+edi*4]
00401289 |. 33F6          xor     esi, esi
0040128B |. C1E0 02       shl     eax, 2
0040128E |. 89B8 B03B4000 mov     dword ptr [eax+403BB0], edi
00401294 |. 8988 A83B4000 mov     dword ptr [eax+403BA8], ecx
0040129A |. 8D90 A03B4000 lea     edx, dword ptr [eax+403BA0]
004012A0 |. 8BC7          mov     eax, edi
004012A2 |. C1E0 09       shl     eax, 9
004012A5 |. 895424 14     mov     dword ptr [esp+14], edx
004012A9 |. 8D88 A0314000 lea     ecx, dword ptr [eax+4031A0]
004012AF |. 894C24 18     mov     dword ptr [esp+18], ecx
004012B3 |> 8B5424 14     /mov     edx, dword ptr [esp+14]
004012B7 |. 8B4424 18     |mov     eax, dword ptr [esp+18]
004012BB |. 8B0D 94314000 |mov     ecx, dword ptr [403194]
004012C1 |. 68 00104000   |push    00401000
004012C6 |. 52            |push    edx
004012C7 |. 53            |push    ebx
004012C8 |. 50            |push    eax
004012C9 |. 51            |push    ecx
004012CA |. FFD5          |call    ebp
004012CC |. 85C0          |test    eax, eax
004012CE |. 75 3D         |jnz     short 0040130D
004012D0 |. FF15 24204000 |call    dword ptr [<&KERNEL32.GetLastEr>; [GetLastError
004012D6 |. 3D F8060000   |cmp     eax, 6F8
004012DB |. 74 0C         |je      short 004012E9
004012DD |. 3D 18070000   |cmp     eax, 718
004012E2 |. 74 05         |je      short 004012E9
004012E4 |. 83F8 08       |cmp     eax, 8
004012E7 |. 75 0E         |jnz     short 004012F7
004012E9 |> 6A 32         |push    32                              ; /Timeout = 50. ms
004012EB |. FF15 14204000 |call    dword ptr [<&KERNEL32.Sleep>]   ; \Sleep
004012F1 |. 46            |inc     esi
004012F2 |. 83FE 05       |cmp     esi, 5
004012F5 |.^ 7C BC         \jl      short 004012B3
004012F7 |> 68 34314000   push    00403134                         ; /format = "ReadFileEx failed.",LF,""
004012FC |. FF15 3C204000 call    dword ptr [<&MSVCRTD.printf>]    ; \printf
00401302 |. 83C4 04       add     esp, 4
00401305 |. 83C8 FF       or      eax, FFFFFFFF
00401308 |. 5F            pop     edi
00401309 |. 5E            pop     esi
0040130A |. 5D            pop     ebp
0040130B |. 5B            pop     ebx
0040130C |. C3            retn
0040130D |> 57            push    edi                              ; /<%d>
0040130E |. 68 0C314000   push    0040310C                         ; |format = "Read #%d queued for overlapped I/O.",LF,""
00401313 |. FF15 3C204000 call    dword ptr [<&MSVCRTD.printf>]    ; \printf
00401319 |. 83C4 08       add     esp, 8
0040131C |. B8 01000000   mov     eax, 1
00401321 |. 5F            pop     edi
00401322 |. 5E            pop     esi
00401323 |. 5D            pop     ebp
00401324 |. 5B            pop     ebx
00401325 \. C3            retn

routu

00401000   . 8B4424 08     mov     eax, dword ptr [esp+8]
00401004   . 8B5424 0C     mov     edx, dword ptr [esp+C]
00401008   . 8B4C24 04     mov     ecx, dword ptr [esp+4]
0040100C   . 50            push    eax                              ; /<%d>
0040100D   . 8B42 10       mov     eax, dword ptr [edx+10]          ; |
00401010   . 51            push    ecx                              ; |<%d>
00401011   . 50            push    eax                              ; |<%d>
00401012   . 68 10304000   push    00403010                         ; |format = "Read #%d returned %d. %d bytes were read.",LF,""
00401017   . FF15 3C204000 call    dword ptr [<&MSVCRTD.printf>]    ; \printf
0040101D   . A1 98314000   mov     eax, dword ptr [403198]
00401022   . 83C4 10       add     esp, 10
00401025   . 40            inc     eax
00401026   . 83F8 05       cmp     eax, 5
00401029   . A3 98314000   mov     dword ptr [403198], eax
0040102E   . 75 0D         jnz     short 0040103D
00401030   . 8B0D 90314000 mov     ecx, dword ptr [403190]
00401036   . 51            push    ecx                              ; /hEvent => NULL
00401037   . FF15 00204000 call    dword ptr [<&KERNEL32.SetEvent>] ; \SetEvent
0040103D   > C2 0C00       retn    0C

ida

本文链接

6-2

2010-07-08T08:26:00Z

/*
* IoByEvnt.c
*
* Sample code for Multithreading Applications in Win32
* This is from Chapter 6, Listing 6-2
*
* Demonstrates how to use event objects instead of
* file handles to signal multiple outstanding
* overlapped operation on a file.
*/

#define WIN32_LEAN_AND_MEAN
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include "MtVerify.h"

//
// Constants
//
#define MAX_REQUESTS    5
#define READ_SIZE       512
#define MAX_TRY_COUNT   5

//
// Function prototypes
//
int QueueRequest(int nIndex, DWORD dwLocation, DWORD dwAmount);
void CheckOsVersion();

//
// Global variables
//

// Need to keep the events in their own array
// so we can wait on them.
HANDLE ghEvents[MAX_REQUESTS];
// Keep track of each individual I/O operation
OVERLAPPED gOverlapped[MAX_REQUESTS];
// Handle to the file of interest.
HANDLE ghFile;
// Need a place to put all this data
char gBuffers[MAX_REQUESTS][READ_SIZE];

int main()
{
    int i;
    BOOL rc;
    char szPath[MAX_PATH];

CheckOsVersion();

    for (i=0; i<MAX_REQUESTS; i++)
    {
        // Read some bytes every few K
        QueueRequest(i, i*16384, READ_SIZE);
    }

printf("QUEUED!!\n");

    // Wait for all the operations to complete.
    MTVERIFY( WaitForMultipleObjects(
               MAX_REQUESTS, ghEvents, TRUE, INFINITE
        ) != WAIT_FAILED );

    // Describe what just happened.
    for (i=0; i<MAX_REQUESTS; i++)
    {
        DWORD dwNumread;

        rc = GetOverlappedResult(
                                ghFile,
                                &gOverlapped[i],
                                &dwNumread,
                                FALSE
                            );
        printf("Read #%d returned %d. %d bytes were read.\n",
                    i, rc, dwNumread);
        CloseHandle(gOverlapped[i].hEvent);
    }

CloseHandle(ghFile);

return EXIT_SUCCESS;
}

/*
* Call ReadFile to start an overlapped request.
* Make sure we handle errors that are recoverable.
* Properly set up the event object for this operation.
*/
int QueueRequest(int nIndex, DWORD dwLocation, DWORD dwAmount)
{
    int i;
    BOOL rc;
    DWORD dwNumread;
    DWORD err;

    MTVERIFY(
        ghEvents[nIndex] = CreateEvent(
                     NULL,    // No security
                     TRUE,    // Manual reset - extremely important!
                     FALSE,   // Initially set Event to non-signaled state
                     NULL     // No name
                    )
    );
    gOverlapped[nIndex].hEvent = ghEvents[nIndex];
    gOverlapped[nIndex].Offset = dwLocation;

    for (i=0; i<MAX_TRY_COUNT; i++)
    {
        rc = ReadFile(
            ghFile,
            gBuffers[nIndex],
            dwAmount,
            &dwNumread,
            &gOverlapped[nIndex]
        );

        // Handle success
        if (rc)
        {
            printf("Read #%d completed immediately.\n", nIndex);
            return TRUE;
        }

err = GetLastError();

        // Handle the error that isn't an error. rc is zero here.
        if (err == ERROR_IO_PENDING)
        {
            // asynchronous i/o is still in progress
            printf("Read #%d queued for overlapped I/O.\n", nIndex);
            return TRUE;
        }

        // Give up on fatal error.
        break;
    }

printf("ReadFile failed.\n");
return -1;
}

//
// Make sure we are running under an operating
// system that supports overlapped I/O to files.
//
void CheckOsVersion()
{
OSVERSIONINFO ver;
BOOL bResult;

ver.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);

bResult = GetVersionEx((LPOSVERSIONINFO) &ver);

    if ( (!bResult) ||
         (ver.dwPlatformId != VER_PLATFORM_WIN32_NT) )
    {
        fprintf(stderr, "IoByEvnt must be run under Windows NT.\n");
  exit(EXIT_FAILURE);
    }

}

od\

00401000 /$ 81EC 0C020000 sub     esp, 20C
00401006 |. 53            push    ebx
00401007 |. 56            push    esi
00401008 |. 57            push    edi
00401009 |. E8 52030000   call    00401360
0040100E |. 8D4424 14     lea     eax, dword ptr [esp+14]
00401012 |. 68 04010000   push    104                              ; /BufSize = 104 (260.)
00401017 |. 50            push    eax                              ; |Buffer
00401018 |. FF15 24204000 call    dword ptr [<&KERNEL32.GetWindows>; \GetWindowsDirectoryA
0040101E |. BF FC304000   mov     edi, 004030FC                    ; ASCII "\WINHLP32.EXE"
00401023 |. 83C9 FF       or      ecx, FFFFFFFF
00401026 |. 33C0          xor     eax, eax
00401028 |. 8D5424 14     lea     edx, dword ptr [esp+14]
0040102C |. F2:AE         repne   scas byte ptr es:[edi]
0040102E |. F7D1          not     ecx
00401030 |. 2BF9          sub     edi, ecx
00401032 |. 50            push    eax                              ; /hTemplateFile => NULL
00401033 |. 8BF7          mov     esi, edi                         ; |
00401035 |. 8BD9          mov     ebx, ecx                         ; |
00401037 |. 8BFA          mov     edi, edx                         ; |
00401039 |. 83C9 FF       or      ecx, FFFFFFFF                    ; |
0040103C |. F2:AE         repne   scas byte ptr es:[edi]           ; |
0040103E |. 8BCB          mov     ecx, ebx                         ; |
00401040 |. 4F            dec     edi                              ; |
00401041 |. C1E9 02       shr     ecx, 2                           ; |
00401044 |. F3:A5         rep     movs dword ptr es:[edi], dword p>; |
00401046 |. 68 00000040   push    40000000                         ; |Attributes = OVERLAPPED
0040104B |. 8BCB          mov     ecx, ebx                         ; |
0040104D |. 6A 03         push    3                                ; |Mode = OPEN_EXISTING
0040104F |. 50            push    eax                              ; |pSecurity => NULL
00401050 |. 83E1 03       and     ecx, 3                           ; |
00401053 |. 6A 03         push    3                                ; |ShareMode = FILE_SHARE_READ|FILE_SHARE_WRITE
00401055 |. 8D4424 28     lea     eax, dword ptr [esp+28]          ; |
00401059 |. 68 00000080   push    80000000                         ; |Access = GENERIC_READ
0040105E |. F3:A4         rep     movs byte ptr es:[edi], byte ptr>; |
00401060 |. 50            push    eax                              ; |FileName
00401061 |. FF15 20204000 call    dword ptr [<&KERNEL32.CreateFile>; \CreateFileA
00401067 |. 83F8 FF       cmp     eax, -1
0040106A |. A3 F0314000   mov     dword ptr [4031F0], eax
0040106F |. 75 20         jnz     short 00401091
00401071 |. 8D4C24 14     lea     ecx, dword ptr [esp+14]
00401075 |. 51            push    ecx                              ; /<%s>
00401076 |. 68 E8304000   push    004030E8                         ; |format = "Could not open %s",LF,""
0040107B |. FF15 40204000 call    dword ptr [<&MSVCRTD.printf>]    ; \printf
00401081 |. 83C4 08       add     esp, 8
00401084 |. 83C8 FF       or      eax, FFFFFFFF
00401087 |. 5F            pop     edi
00401088 |. 5E            pop     esi
00401089 |. 5B            pop     ebx
0040108A |. 81C4 0C020000 add     esp, 20C
00401090 |. C3            retn
00401091 |> 33FF          xor     edi, edi
00401093 |. 33F6          xor     esi, esi
00401095 |> 68 00020000   /push    200
0040109A |. 56            |push    esi
0040109B |. 57            |push    edi
0040109C |. E8 2F010000   |call    004011D0
004010A1 |. 83C4 0C       |add     esp, 0C
004010A4 |. 81C6 00400000 |add     esi, 4000
004010AA |. 47            |inc     edi
004010AB |. 81FE 00400100 |cmp     esi, 14000
004010B1 |.^ 72 E2         \jb      short 00401095
004010B3 |. 68 DC304000   push    004030DC                         ; /format = "QUEUED!!",LF,""
004010B8 |. FF15 40204000 call    dword ptr [<&MSVCRTD.printf>]    ; \printf
004010BE |. 83C4 04       add     esp, 4
004010C1 |. 6A FF         push    -1                               ; /Timeout = INFINITE
004010C3 |. 6A 01         push    1                                ; |WaitForAll = TRUE
004010C5 |. 68 00324000   push    00403200                         ; |pObjects = IoByEvnt.00403200
004010CA |. 6A 05         push    5                                ; |nObjects = 5
004010CC |. FF15 1C204000 call    dword ptr [<&KERNEL32.WaitForMul>; \WaitForMultipleObjects
004010D2 |. 83F8 FF       cmp     eax, -1
004010D5 |. 0F85 89000000 jnz     00401164
004010DB |. FF15 18204000 call    dword ptr [<&KERNEL32.GetLastErr>; [GetLastError
004010E1 |. 6A 00         push    0                                ; /Arguments = NULL
004010E3 |. 8D5424 10     lea     edx, dword ptr [esp+10]          ; |
004010E7 |. 6A 00         push    0                                ; |BufSize = 0
004010E9 |. 52            push    edx                              ; |Buffer
004010EA |. 6A 00         push    0                                ; |LanguageId = 0 (LANG_NEUTRAL)
004010EC |. 50            push    eax                              ; |MessageId
004010ED |. 6A 00         push    0                                ; |pSource = NULL
004010EF |. 68 00110000   push    1100                             ; |Flags = ALLOCATE_BUFFER|FROM_SYSTEM|0
004010F4 |. FF15 14204000 call    dword ptr [<&KERNEL32.FormatMess>; \FormatMessageA
004010FA |. 8B4424 0C     mov     eax, dword ptr [esp+C]
004010FE |. 8D8C24 180100>lea     ecx, dword ptr [esp+118]
00401105 |. 50            push    eax                              ; /<%s>
00401106 |. 68 8C304000   push    0040308C                         ; |<%s> = "WaitForMultipleObjects( MAX_REQUESTS, ghEvents, TRUE, INFINITE ) != WAIT_FAILED"
0040110B |. 68 80304000   push    00403080                         ; |<%s> = "IoByEvnt.c"
00401110 |. 6A 53         push    53                               ; |<%d> = 53 (83.)
00401112 |. 68 3C304000   push    0040303C                         ; |Format = LF,"The following call failed at line %d in %s:",LF,LF,"    %s",LF,LF,"Reason: %s",LF,""
00401117 |. 51            push    ecx                              ; |s
00401118 |. FF15 7C204000 call    dword ptr [<&USER32.wsprintfA>] ; \wsprintfA
0040111E |. 8DBC24 300100>lea     edi, dword ptr [esp+130]
00401125 |. 83C9 FF       or      ecx, FFFFFFFF
00401128 |. 33C0          xor     eax, eax
0040112A |. 83C4 18       add     esp, 18
0040112D |. F2:AE         repne   scas byte ptr es:[edi]
0040112F |. F7D1          not     ecx
00401131 |. 8D5424 10     lea     edx, dword ptr [esp+10]
00401135 |. 6A 00         push    0                                ; /pOverlapped = NULL
00401137 |. 49            dec     ecx                              ; |
00401138 |. 52            push    edx                              ; |pBytesWritten
00401139 |. 8D8424 200100>lea     eax, dword ptr [esp+120]         ; |
00401140 |. 51            push    ecx                              ; |nBytesToWrite
00401141 |. 50            push    eax                              ; |Buffer
00401142 |. 6A F4         push    -0C                              ; |/DevType = STD_ERROR_HANDLE
00401144 |. FF15 10204000 call    dword ptr [<&KERNEL32.GetStdHand>; |\GetStdHandle
0040114A |. 50            push    eax                              ; |hFile
0040114B |. FF15 0C204000 call    dword ptr [<&KERNEL32.WriteFile>>; \WriteFile
00401151 |. 68 B80B0000   push    0BB8                             ; /Timeout = 3000. ms
00401156 |. FF15 08204000 call    dword ptr [<&KERNEL32.Sleep>]    ; \Sleep
0040115C |. 6A 01         push    1                                ; /status = 1
0040115E |. FF15 3C204000 call    dword ptr [<&MSVCRTD.exit>]      ; \exit
00401164 |> 8B1D 04204000 mov     ebx, dword ptr [<&KERNEL32.Close>; kernel32.CloseHandle
0040116A |. 55            push    ebp
0040116B |. 8B2D 00204000 mov     ebp, dword ptr [<&KERNEL32.GetOv>; kernel32.GetOverlappedResult
00401171 |. 33FF          xor     edi, edi
00401173 |. BE 303C4000   mov     esi, 00403C30
00401178 |> A1 F0314000   mov     eax, dword ptr [4031F0]
0040117D |. 8D4C24 10     lea     ecx, dword ptr [esp+10]
00401181 |. 6A 00         push    0
00401183 |. 8D56 F0       lea     edx, dword ptr [esi-10]
00401186 |. 51            push    ecx
00401187 |. 52            push    edx
00401188 |. 50            push    eax
00401189 |. FFD5          call    ebp
0040118B |. 8B4C24 10     mov     ecx, dword ptr [esp+10]
0040118F |. 51            push    ecx                              ; /<%d>
00401190 |. 50            push    eax                              ; |<%d>
00401191 |. 57            push    edi                              ; |<%d>
00401192 |. 68 10304000   push    00403010                         ; |format = "Read #%d returned %d. %d bytes were read.",LF,""
00401197 |. FF15 40204000 call    dword ptr [<&MSVCRTD.printf>]    ; \printf
0040119D |. 8B16          mov     edx, dword ptr [esi]
0040119F |. 83C4 10       add     esp, 10
004011A2 |. 52            push    edx
004011A3 |. FFD3          call    ebx
004011A5 |. 83C6 14       add     esi, 14
004011A8 |. 47            inc     edi
004011A9 |. 81FE 943C4000 cmp     esi, 00403C94
004011AF |.^ 7C C7         jl      short 00401178
004011B1 |. A1 F0314000   mov     eax, dword ptr [4031F0]
004011B6 |. 50            push    eax
004011B7 |. FFD3          call    ebx
004011B9 |. 5D            pop     ebp
004011BA |. 5F            pop     edi
004011BB |. 5E            pop     esi
004011BC |. 33C0          xor     eax, eax
004011BE |. 5B            pop     ebx
004011BF |. 81C4 0C020000 add     esp, 20C
004011C5 \. C3            retn

ida

本文链接

6-1

2010-07-08T08:11:00Z

/*
* IoByFile.c
*
* Sample code for Multithreading Applications in Win32
* This is from Chapter 6, Listing 6-1
*
* Demonstrates how a file handle becomes signaled
* when an overlapped operation on the handle's file
* is completed. Notice that sometimes the operation
* is completed immediately. The operation is only
* queued, or pended, if ERROR_IO_PENDING is returned.
*/

#define WIN32_LEAN_AND_MEAN
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>

//
// Constants
//
#define READ_SIZE 512

//
// Function prototypes
//
void CheckOsVersion();

int main()
{
    BOOL rc;
    HANDLE hFile;
    DWORD numread;
    OVERLAPPED overlap;
    char buf[READ_SIZE];
    char szPath[MAX_PATH];

CheckOsVersion();

    GetWindowsDirectory(szPath, sizeof(szPath));
    strcat(szPath, "http://www.cnblogs.com/nanshouyong326/admin/file://WINHLP32.EXE/");
    // Open the file for overlapped reads
    hFile = CreateFile( szPath,
                    GENERIC_READ,
                    FILE_SHARE_READ|FILE_SHARE_WRITE,
                    NULL,
                    OPEN_EXISTING,
                    FILE_FLAG_OVERLAPPED,
                    NULL
                );
    if (hFile == INVALID_HANDLE_VALUE)
    {
        printf("Could not open %s\n", szPath);
        return -1;
    }

    // Initialize the OVERLAPPED structure
    memset(&overlap, 0, sizeof(overlap));
    overlap.Offset = 1500;

    // Request the data
    rc = ReadFile(
                hFile,
                buf,
                READ_SIZE,
                &numread,
                &overlap
            );
    printf("Issued read request\n");

    // Was the operation queued?
    if (rc)
    {
        // The data was read successfully
        printf("Request was returned immediately\n");
    }
    else
    {
        if (GetLastError() == ERROR_IO_PENDING)
        {
            // We could do something else for awhile here...

            printf("Request queued, waiting...\n");
            WaitForSingleObject(hFile, INFINITE);
            printf("Request completed.\n");

            rc = GetOverlappedResult(
                                    hFile,
                                    &overlap,
                                    &numread,
                                    FALSE
                                );
            printf("Result was %d\n", rc);
        }
        else
        {
   // We should check for memory and quota
   // errors here and retry. See the samples
   // IoByEvnt and IoByAPC.

            // Something went wrong
            printf("Error reading file\n");
        }
    }

CloseHandle(hFile);

return EXIT_SUCCESS;
}

//
// Make sure we are running under an operating
// system that supports overlapped I/O to files.
//
void CheckOsVersion()
{
OSVERSIONINFO ver;
BOOL bResult;

ver.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);

bResult = GetVersionEx((LPOSVERSIONINFO) &ver);

    if ( (!bResult) ||
         (ver.dwPlatformId != VER_PLATFORM_WIN32_NT) )
    {
        fprintf(stderr, "IoByFile must be run under Windows NT.\n");
  exit(EXIT_FAILURE);
    }

}

00401000 /$ 81EC 1C030000 sub     esp, 31C
00401006 |. 53            push    ebx
00401007 |. 56            push    esi
00401008 |. 57            push    edi
00401009 |. E8 52010000   call    00401160
0040100E |. 8D4424 24     lea     eax, dword ptr [esp+24]
00401012 |. 68 04010000   push    104                              ; /BufSize = 104 (260.)
00401017 |. 50            push    eax                              ; |Buffer
00401018 |. FF15 18204000 call    dword ptr [<&KERNEL32.GetWindows>; \GetWindowsDirectoryA
0040101E |. BF B4304000   mov     edi, 004030B4                    ; ASCII "\WINHLP32.EXE"
00401023 |. 83C9 FF       or      ecx, FFFFFFFF
00401026 |. 33C0          xor     eax, eax
00401028 |. 8D5424 24     lea     edx, dword ptr [esp+24]
0040102C |. F2:AE         repne   scas byte ptr es:[edi]
0040102E |. F7D1          not     ecx
00401030 |. 2BF9          sub     edi, ecx
00401032 |. 50            push    eax                              ; /hTemplateFile => NULL
00401033 |. 8BF7          mov     esi, edi                         ; |
00401035 |. 8BD9          mov     ebx, ecx                         ; |
00401037 |. 8BFA          mov     edi, edx                         ; |
00401039 |. 83C9 FF       or      ecx, FFFFFFFF                    ; |
0040103C |. F2:AE         repne   scas byte ptr es:[edi]           ; |
0040103E |. 8BCB          mov     ecx, ebx                         ; |
00401040 |. 4F            dec     edi                              ; |
00401041 |. C1E9 02       shr     ecx, 2                           ; |
00401044 |. F3:A5         rep     movs dword ptr es:[edi], dword p>; |
00401046 |. 68 00000040   push    40000000                         ; |Attributes = OVERLAPPED
0040104B |. 8BCB          mov     ecx, ebx                         ; |
0040104D |. 6A 03         push    3                                ; |Mode = OPEN_EXISTING
0040104F |. 50            push    eax                              ; |pSecurity => NULL
00401050 |. 83E1 03       and     ecx, 3                           ; |
00401053 |. 6A 03         push    3                                ; |ShareMode = FILE_SHARE_READ|FILE_SHARE_WRITE
00401055 |. 8D4424 38     lea     eax, dword ptr [esp+38]          ; |
00401059 |. 68 00000080   push    80000000                         ; |Access = GENERIC_READ
0040105E |. F3:A4         rep     movs byte ptr es:[edi], byte ptr>; |
00401060 |. 50            push    eax                              ; |FileName
00401061 |. FF15 14204000 call    dword ptr [<&KERNEL32.CreateFile>; \CreateFileA
00401067 |. 8BF0          mov     esi, eax
00401069 |. 83FE FF       cmp     esi, -1
0040106C |. 75 1F         jnz     short 0040108D
0040106E |. 8D4C24 24     lea     ecx, dword ptr [esp+24]
00401072 |. 51            push    ecx                              ; /<%s>
00401073 |. 68 A0304000   push    004030A0                         ; |format = "Could not open %s",LF,""
00401078 |. FF15 24204000 call    dword ptr [<&MSVCRTD.printf>]    ; \printf
0040107E |. 83C4 08       add     esp, 8
00401081 |. 0BC6          or      eax, esi
00401083 |. 5F            pop     edi
00401084 |. 5E            pop     esi
00401085 |. 5B            pop     ebx
00401086 |. 81C4 1C030000 add     esp, 31C
0040108C |. C3            retn
0040108D |> 33D2          xor     edx, edx
0040108F |. 8D4424 10     lea     eax, dword ptr [esp+10]
00401093 |. 895424 10     mov     dword ptr [esp+10], edx
00401097 |. 8D4C24 0C     lea     ecx, dword ptr [esp+C]
0040109B |. 895424 14     mov     dword ptr [esp+14], edx
0040109F |. 50            push    eax                              ; /pOverlapped
004010A0 |. 895424 1C     mov     dword ptr [esp+1C], edx          ; |
004010A4 |. 51            push    ecx                              ; |pBytesRead
004010A5 |. 895424 24     mov     dword ptr [esp+24], edx          ; |
004010A9 |. 68 00020000   push    200                              ; |BytesToRead = 200 (512.)
004010AE |. 895424 2C     mov     dword ptr [esp+2C], edx          ; |
004010B2 |. 8D9424 340100>lea     edx, dword ptr [esp+134]         ; |
004010B9 |. 52            push    edx                              ; |Buffer
004010BA |. 56            push    esi                              ; |hFile
004010BB |. C74424 2C DC0>mov     dword ptr [esp+2C], 5DC          ; |
004010C3 |. FF15 10204000 call    dword ptr [<&KERNEL32.ReadFile>] ; \ReadFile
004010C9 |. 8B3D 24204000 mov     edi, dword ptr [<&MSVCRTD.printf>; MSVCRTD.printf
004010CF |. 68 88304000   push    00403088                         ; /format = "Issued read request",LF,""
004010D4 |. 8BD8          mov     ebx, eax                         ; |
004010D6 |. FFD7          call    edi                              ; \printf
004010D8 |. 83C4 04       add     esp, 4
004010DB |. 85DB          test    ebx, ebx
004010DD |. 74 07         je      short 004010E6
004010DF |. 68 64304000   push    00403064                         ; ASCII "Request was returned immediately",LF
004010E4 |. EB 60         jmp     short 00401146
004010E6 |> FF15 0C204000 call    dword ptr [<&KERNEL32.GetLastErr>; [GetLastError
004010EC |. 3D E5030000   cmp     eax, 3E5
004010F1 |. 75 4E         jnz     short 00401141
004010F3 |. 68 48304000   push    00403048                         ; ASCII "Request queued, waiting...",LF
004010F8 |. FFD7          call    edi
004010FA |. 83C4 04       add     esp, 4
004010FD |. 6A FF         push    -1                               ; /Timeout = INFINITE
004010FF |. 56            push    esi                              ; |hObject
00401100 |. FF15 08204000 call    dword ptr [<&KERNEL32.WaitForSin>; \WaitForSingleObject
00401106 |. 68 34304000   push    00403034                         ; ASCII "Request completed.",LF
0040110B |. FFD7          call    edi
0040110D |. 83C4 04       add     esp, 4
00401110 |. 8D4424 0C     lea     eax, dword ptr [esp+C]
00401114 |. 8D4C24 10     lea     ecx, dword ptr [esp+10]
00401118 |. 6A 00         push    0                                ; /Wait = FALSE
0040111A |. 50            push    eax                              ; |pByteCount
0040111B |. 51            push    ecx                              ; |pOverlapped
0040111C |. 56            push    esi                              ; |hFile
0040111D |. FF15 04204000 call    dword ptr [<&KERNEL32.GetOverlap>; \GetOverlappedResult
00401123 |. 50            push    eax
00401124 |. 68 24304000   push    00403024                         ; ASCII "Result was %d",LF
00401129 |. FFD7          call    edi
0040112B |. 83C4 08       add     esp, 8
0040112E |. 56            push    esi                              ; /hObject
0040112F |. FF15 00204000 call    dword ptr [<&KERNEL32.CloseHandl>; \CloseHandle
00401135 |. 5F            pop     edi
00401136 |. 5E            pop     esi
00401137 |. 33C0          xor     eax, eax
00401139 |. 5B            pop     ebx
0040113A |. 81C4 1C030000 add     esp, 31C
00401140 |. C3            retn
00401141 |> 68 10304000   push    00403010                         ; ASCII "Error reading file",LF
00401146 |> FFD7          call    edi
00401148 |. 83C4 04       add     esp, 4
0040114B |. 56            push    esi                              ; /hObject
0040114C |. FF15 00204000 call    dword ptr [<&KERNEL32.CloseHandl>; \CloseHandle
00401152 |. 5F            pop     edi
00401153 |. 5E            pop     esi
00401154 |. 33C0          xor     eax, eax
00401156 |. 5B            pop     ebx
00401157 |. 81C4 1C030000 add     esp, 31C
0040115D \. C3            retn

ida

.text:00401000
.text:00401000 ; =============== S U B R O U T I N E =======================================
.text:00401000
.text:00401000
.text:00401000 ; int __cdecl main(int argc, const char **argv, const char *envp)
.text:00401000 _main           proc near               ; CODE XREF: start+FAp
.text:00401000
.text:00401000 NumberOfBytesTransferred= dword ptr -31Ch
.text:00401000 Overlapped      = _OVERLAPPED ptr -318h
.text:00401000 FileName        = byte ptr -304h
.text:00401000 Buffer          = byte ptr -200h
.text:00401000 argc            = dword ptr 4
.text:00401000 argv            = dword ptr 8
.text:00401000 envp            = dword ptr 0Ch
.text:00401000
.text:00401000                 sub     esp, 31Ch
.text:00401006                 push    ebx
.text:00401007                 push    esi
.text:00401008                 push    edi
.text:00401009                 call    sub_401160
.text:0040100E                 lea     eax, [esp+328h+FileName]
.text:00401012                 push    104h            ; uSize
.text:00401017                 push    eax             ; lpBuffer
.text:00401018                 call    ds:GetWindowsDirectoryA
.text:0040101E                 mov     edi, offset aWinhlp32_exe ; "http://www.cnblogs.com/nanshouyong326/admin/file://WINHLP32.EXE/"
.text:00401023                 or      ecx, 0FFFFFFFFh
.text:00401026                 xor     eax, eax
.text:00401028                 lea     edx, [esp+328h+FileName]
.text:0040102C                 repne scasb
.text:0040102E                 not     ecx
.text:00401030                 sub     edi, ecx
.text:00401032                 push    eax             ; hTemplateFile
.text:00401033                 mov     esi, edi
.text:00401035                 mov     ebx, ecx
.text:00401037                 mov     edi, edx
.text:00401039                 or      ecx, 0FFFFFFFFh
.text:0040103C                 repne scasb
.text:0040103E                 mov     ecx, ebx
.text:00401040                 dec     edi
.text:00401041                 shr     ecx, 2
.text:00401044                 rep movsd
.text:00401046                 push    40000000h       ; dwFlagsAndAttributes
.text:0040104B                 mov     ecx, ebx
.text:0040104D                 push    3               ; dwCreationDisposition
.text:0040104F                 push    eax             ; lpSecurityAttributes
.text:00401050                 and     ecx, 3
.text:00401053                 push    3               ; dwShareMode
.text:00401055                 lea     eax, [esp+33Ch+FileName]
.text:00401059                 push    80000000h       ; dwDesiredAccess
.text:0040105E                 rep movsb
.text:00401060                 push    eax             ; lpFileName
.text:00401061                 call    ds:CreateFileA
.text:00401067                 mov     esi, eax
.text:00401069                 cmp     esi, 0FFFFFFFFh
.text:0040106C                 jnz     short loc_40108D
.text:0040106E                 lea     ecx, [esp+328h+FileName]
.text:00401072                 push    ecx
.text:00401073                 push    offset Format   ; "Could not open %s\n"
.text:00401078                 call    ds:printf
.text:0040107E                 add     esp, 8
.text:00401081                 or      eax, esi
.text:00401083                 pop     edi
.text:00401084                 pop     esi
.text:00401085                 pop     ebx
.text:00401086                 add     esp, 31Ch
.text:0040108C                 retn
.text:0040108D ; ---------------------------------------------------------------------------
.text:0040108D
.text:0040108D loc_40108D:                             ; CODE XREF: _main+6Cj
.text:0040108D                 xor     edx, edx
.text:0040108F                 lea     eax, [esp+328h+Overlapped]
.text:00401093                 mov     [esp+328h+Overlapped.Internal], edx
.text:00401097                 lea     ecx, [esp+328h+NumberOfBytesTransferred]
.text:0040109B                 mov     [esp+328h+Overlapped.InternalHigh], edx
.text:0040109F                 push    eax             ; lpOverlapped
.text:004010A0                 mov     dword ptr [esp+32Ch+Overlapped.anonymous_0], edx
.text:004010A4                 push    ecx             ; lpNumberOfBytesRead
.text:004010A5                 mov     dword ptr [esp+330h+Overlapped.anonymous_0+4], edx
.text:004010A9                 push    200h            ; nNumberOfBytesToRead
.text:004010AE                 mov     [esp+334h+Overlapped.hEvent], edx
.text:004010B2                 lea     edx, [esp+334h+Buffer]
.text:004010B9                 push    edx             ; lpBuffer
.text:004010BA                 push    esi             ; hFile
.text:004010BB                 mov     dword ptr [esp+33Ch+Overlapped.anonymous_0], 5DCh
.text:004010C3                 call    ds:ReadFile
.text:004010C9                 mov     edi, ds:printf
.text:004010CF                 push    offset aIssuedReadRequ ; "Issued read request\n"
.text:004010D4                 mov     ebx, eax
.text:004010D6                 call    edi ; printf
.text:004010D8                 add     esp, 4
.text:004010DB                 test    ebx, ebx
.text:004010DD                 jz      short loc_4010E6
.text:004010DF                 push    offset aRequestWasRetu ; "Request was returned immediately\n"
.text:004010E4                 jmp     short loc_401146
.text:004010E6 ; ---------------------------------------------------------------------------
.text:004010E6
.text:004010E6 loc_4010E6:                             ; CODE XREF: _main+DDj
.text:004010E6                 call    ds:GetLastError
.text:004010EC                 cmp     eax, ERROR_IO_PENDING
.text:004010F1                 jnz     short loc_401141
.text:004010F3                 push    offset aRequestQueuedW ; "Request queued, waiting...\n"
.text:004010F8                 call    edi ; printf
.text:004010FA                 add     esp, 4
.text:004010FD                 push    0FFFFFFFFh      ; dwMilliseconds
.text:004010FF                 push    esi             ; hHandle
.text:00401100                 call    ds:WaitForSingleObject
.text:00401106                 push    offset aRequestComplet ; "Request completed.\n"
.text:0040110B                 call    edi ; printf
.text:0040110D                 add     esp, 4
.text:00401110                 lea     eax, [esp+328h+NumberOfBytesTransferred]
.text:00401114                 lea     ecx, [esp+328h+Overlapped]
.text:00401118                 push    0               ; bWait
.text:0040111A                 push    eax             ; lpNumberOfBytesTransferred
.text:0040111B                 push    ecx             ; lpOverlapped
.text:0040111C                 push    esi             ; hFile
.text:0040111D                 call    ds:GetOverlappedResult
.text:00401123                 push    eax
.text:00401124                 push    offset aResultWasD ; "Result was %d\n"
.text:00401129                 call    edi ; printf
.text:0040112B                 add     esp, 8
.text:0040112E                 push    esi             ; hObject
.text:0040112F                 call    ds:CloseHandle
.text:00401135                 pop     edi
.text:00401136                 pop     esi
.text:00401137                 xor     eax, eax
.text:00401139                 pop     ebx
.text:0040113A                 add     esp, 31Ch
.text:00401140                 retn
.text:00401141 ; ---------------------------------------------------------------------------
.text:00401141
.text:00401141 loc_401141:                             ; CODE XREF: _main+F1j
.text:00401141                 push    offset aErrorReadingFi ; "Error reading file\n"
.text:00401146
.text:00401146 loc_401146:                             ; CODE XREF: _main+E4j
.text:00401146                 call    edi ; printf
.text:00401148                 add     esp, 4
.text:0040114B                 push    esi             ; hObject
.text:0040114C                 call    ds:CloseHandle
.text:00401152                 pop     edi
.text:00401153                 pop     esi
.text:00401154                 xor     eax, eax
.text:00401156                 pop     ebx
.text:00401157                 add     esp, 31Ch
.text:0040115D                 retn
.text:0040115D _main           endp
.text:0040115D
.text:0040115D ; ---------------------------------------------------------------------------
.text:0040115E                 align 10h
.text:00401160

本文链接

博客园_我思考..我存在..

java monitor file

java mina unix client

asp.net 跑 socket server

epoll 多线程 服务器

PAZU 是4Fang 为配合“四方在线”软件于2004年开发的WEB打印控件，适用于各种WEB软件项目的打印。

jbpm表说明

7-1

6-3

6-2

6-1

epoll 多线程服务器