![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mutex.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / q_a / samples / mutex|
Return to mutex.c CVS log | Up to [WindowsNT SDKs] / q_a / samples / mutex |
1.1 root 1: /*************************************************************************\
2: * PROGRAM: Mutex.c
3: *
4: * PURPOSE:
5: *
6: * To demonstrate the use of a named mutex between processes.
7: *
8: * GLOBAL VARIABLES:
9: *
10: * HANDLE hInst; - Instance handle.
11: *
12: * HWND hWnd; - Client window handle.
13: *
14: * CHAR Buf[80], Buf2[80];
15: * Error message buffers.
16: *
17: * FUNCTIONS:
18: *
19: * WinMain() - Initializes the window, and process the message loop.
20: * MainWndProc() - To handle the messages to the main window.
21: * RequestProc() - Prints a message when it gets access to the mutex.
22: *
23: * COMMENTS:
24: *
25: * Overview:
26: * Between processes it is better to use a mutex than a semaphore
27: * to control access to a mutual resourse. A serious draw back
28: * to a semaphore is that any thread can call ReleaseSemaphore
29: * and change its usage count (or access). Another drawback is that
30: * if a thread or process dies before calling ReleaseSemaphore, than
31: * no other process or thread will be able to access it (because the
32: * use count hasn't been updated). When a process controlling
33: * a mutex dies, the mutex is freed for other processes.
34: *
35: * To Use:
36: * Start any number of instances of this application. Each instance
37: * will start a thread which will request access to the mutex.
38: * when the thread has the mutex, it will print a message in the
39: * application window "I HAVE CONTROL OF THE MUTEX!", and then
40: * sleep for two seconds. It will then wakeup, erase the message,
41: * release the mutex; and then sleep for another two seconds before
42: * asking for control again. By starting several instances, you will
43: * see that each instance will often have to wait longer than its two
44: * seconds before it gets control.
45: *
46: \*************************************************************************/
47:
48: #include <windows.h>
49: #include <stdlib.h>
50: #include <stdio.h>
51: #include "mutex.h"
52:
53: // used for error messages.
54: #define WERR(who,where) {sprintf(Buf,"ERROR: %s returned %u, line: %u", who, GetLastError(), __LINE__);\
55: sprintf(Buf2,"From within %s", where);\
56: MessageBox(hWnd, Buf, Buf2, MB_OK);}
57:
58:
59: CHAR Buf[80];
60: CHAR Buf2[80];
61: HANDLE hInst;
62: HWND hWnd;
63:
64:
65:
66:
67: /*************************************************************************\
68: *
69: * FUNCTION: WinMain(HANDLE, HANDLE, LPSTR, int)
70: *
71: * PURPOSE: Calls initialization function, processes message loop.
72: *
73: * COMMENTS: A fairly standard WinMain.
74: *
75: \*************************************************************************/
76:
77: int APIENTRY WinMain (HANDLE hInstance,
78: HANDLE hPrevInstance,
79: LPSTR lpCmdLine,
80: int nCmdShow)
81:
82:
83: {
84:
85: MSG msg;
86: WNDCLASS wc;
87:
88: UNREFERENCED_PARAMETER( lpCmdLine );
89: UNREFERENCED_PARAMETER( hPrevInstance );
90:
91: hInst = hInstance;
92:
93: wc.style = NULL; // Replaces CS_SIZEREDRAW.
94: wc.lpfnWndProc = (WNDPROC)MainWndProc; // The client window procedure.
95: wc.cbClsExtra = 0; // No room reserved for extra data.
96: wc.cbWndExtra = 0;
97: wc.hInstance = hInstance;
98: wc.hIcon = LoadIcon (NULL, IDI_APPLICATION);
99: wc.hCursor = LoadCursor (NULL, IDC_ARROW);
100: wc.hbrBackground = GetStockObject (WHITE_BRUSH);
101: wc.lpszMenuName = "";
102: wc.lpszClassName = "MutexWClass";
103:
104: RegisterClass(&wc);
105:
106: hWnd = CreateWindow ("MutexWClass",
107: "Mutex Between Processes Sample",
108: WS_OVERLAPPEDWINDOW,
109: CW_USEDEFAULT,
110: CW_USEDEFAULT,
111: CW_USEDEFAULT,
112: CW_USEDEFAULT,
113: NULL,
114: NULL,
115: hInstance,
116: NULL);
117:
118:
119: ShowWindow (hWnd, nCmdShow);
120:
121: while (GetMessage (&msg, NULL, NULL, NULL))
122: DispatchMessage (&msg); // Dispatch message to window.
123:
124: return (msg.wParam); // Returns value from PostQuitMessage.
125:
126: }
127:
128: /*************************************************************************\
129: *
130: * FUNCTION: MainWndProc (HWND, UINT, UINT, LONG)
131: *
132: * PURPOSE: To process messages. To launch client and server threads
133: * as appropriate.
134: *
135: *
136: * MESSAGES:
137: *
138: * WM_CREATE - Creates a thread.
139: *
140: * WM_DESTROY - Standard, destroys the window.
141: *
142: * CALLED BY:
143: *
144: * WinMain();
145: *
146: * CALLS TO:
147: *
148: * RequestProc() - The thread procedure.
149: *
150: \*************************************************************************/
151:
152: LONG APIENTRY MainWndProc (HWND hwnd,
153: UINT message,
154: UINT wParam,
155: LONG lParam)
156: {
157: DWORD ThreadID;
158: HANDLE hThread;
159:
160: switch (message)
161: {
162:
163: case WM_CREATE:
164:
165: hThread = CreateThread (NULL, 0,
166: (LPTHREAD_START_ROUTINE)RequestProc,
167: (LPVOID)NULL, NULL,
168: (LPDWORD)&ThreadID);
169: if (!hThread)
170: WERR("CreateThread", "WM_CREATE");
171: CloseHandle (hThread);
172: return (0);
173:
174:
175: case WM_DESTROY :
176: PostQuitMessage (0);
177: return (0);
178: }
179: return DefWindowProc (hwnd, message, wParam, lParam);
180: }
181:
182:
183: /*************************************************************************\
184: *
185: * FUNCTION: VOID RequestProc (VOID)
186: *
187: * PURPOSE: This thread tries to create the Mutex. Only the first thread
188: * created will succeed, all others will fail. Then this thread
189: * tries to open the mutex. If successful, it
190: * enters a loop. The loop asks for control of the mutex.
191: * Once it has control, it prints the message in the application
192: * window, and sleeps for two seconds. It then releases
193: * the mutex, erases the message, and sleeps another two
194: * seconds before trying to get control again.
195: *
196: * VARIABLES USED:
197: *
198: * - hMutex:
199: * A handle to the mutex.
200: *
201: * - rect, textRect:
202: * RECT structures. One for the client area, one for the
203: * text location.
204: *
205: * - hDC: The DC of the window.
206: *
207: * - X, Y: Integers/coordinates used to locate the text
208: *
209: * - hBrush:
210: * Handle to a brush, used to erase the old text.
211: *
212: * - size: A SIZE struct, used to determin the size of the font
213: * and message on the window.
214: *
215: *
216: \*************************************************************************/
217: VOID RequestProc(VOID)
218: {
219: HANDLE hMutex;
220: RECT rect, textRect;
221: HDC hDC;
222: LONG X, Y;
223: SIZE size;
224: DWORD retCode;
225:
226:
227:
228: hMutex = CreateMutex (NULL, FALSE, "my_mutex");
229: if (!hMutex)
230: {
231: retCode = GetLastError();
232: if (retCode != ERROR_ALREADY_EXISTS)
233: {
234: SetLastError(retCode);
235: WERR("CreateMutex", "WM_CREATE");
236: PostQuitMessage(0);
237: }
238: }
239:
240: hMutex = OpenMutex(MUTEX_ALL_ACCESS, FALSE, "my_mutex");
241: if (!hMutex)
242: {
243: WERR("OpenMutex", "From RequestProc");
244: return;
245: }
246:
247: hDC = GetDC (hWnd);
248: GetTextExtentPoint (hDC, "I HAVE CONTROL OF THE MUTEX!", 28, &size);
249: ReleaseDC (hWnd, hDC);
250:
251: while(!IsWindow(hWnd));
252:
253: while(1)
254: {
255: WaitForSingleObject (hMutex, INFINITE);
256:
257: hDC = GetDC (hWnd);
258: GetClientRect (hWnd, &rect);
259: X = ((rect.right - rect.left) / 2) - (size.cx / 2);
260: Y = (rect.bottom - rect.top) / 2;
261:
262: TextOut (hDC, X, Y, "I HAVE CONTROL OF THE MUTEX!", 28);
263:
264: MessageBeep (0); // Forces a flush of the window buffers.
265: Sleep(2000);
266:
267: textRect.left = X,
268: textRect.right = X + size.cx;
269: textRect.top = Y;
270: textRect.bottom = Y + size.cy;
271: FillRect (hDC, &textRect, GetStockObject(WHITE_BRUSH));
272:
273: ReleaseDC(hWnd, hDC);
274: ReleaseMutex (hMutex);
275: Sleep(2000);
276: }
277: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.