This browser is no longer supported.
Upgrade to Microsoft Edge to take advantage of the latest features, security updates, and technical support.
main.cpp:
DWORD WINAPI ThreadMain(LPVOID lpParam) {
// doing thread-specific tasks, and send results to main thread at anytime
return 0;
}
int WINAPI wWinMain(HINSTANCE, HINSTANCE, PWSTR, int) {
DWORD threadId;
HANDLE hThread;
CreateThread(/* ... */);
// doing main tasks here, and also looking for `hThread` is send an event
WaitForSingleObject(hThread, INFINITE);
}
In short, I need a way for two threads communicate each other.
What kind of communication do you need?
For example, the main thread (the thread that first started when running the programs) start the "network" thread.
So there are two threads: main thread and network thread.
I know how to do networking with Windows API, so let's just talk about how two threads can communicate, rather writing real networking code.
Network thread must send an "event" or "message" to the main thread if something happens inside the network thread.
Basically, I need a way for two threads communicate each other
For such communication, I think that the network thread can put the data to some object, list or stack, then use SetEvent. The main thread, when there are no other tasks to perform, will use WaitForSingleObject or WaitForMultipleObjects to wait for these data or other events, then use the data. The functions related to critical sections will be used too.
Instead of Windows functions, you can use the corresponding standard STL functions.
You can see MSDN doc and sample at : Sharing common resources between threads
Hello,
another way is by sending messages. When you create the thread, put the main window handle into the thread's argument, and save the thread variable. Then you can for example use SendMessage.
Regards, Guido
Hi！
Welcome to Microsoft Q&A!
I give you two methods to implement thread communication and thread synchronization. Both methods implement the same functionality .
First, we can use Event, here is the sample:
#include<windows.h>
#include<cstdio>
HANDLE g_hSet, g_hClear;
int g_Max = 10;//the limit of goods
int g_Number = 0;
//producer
DWORD WINAPI ThreadProduct(LPVOID pM)
{
for (int i = 0; i < g_Max; i++)
{
WaitForSingleObject(g_hSet, INFINITE);
g_Number = 0;
DWORD id = GetCurrentThreadId();
printf("Producer %d put stuff in %d market\n", id, g_Number);
SetEvent(g_hClear);
}
return 0;
}
//Consumer
DWORD WINAPI ThreadConsumer(LPVOID pM)
{
for (int i = 0; i < g_Max; i++)
{
WaitForSingleObject(g_hClear, INFINITE);
g_Number = 0;
DWORD id = GetCurrentThreadId();
printf("-----Consumer %d take out stuff in %d market\n", id, g_Number);
SetEvent(g_hSet);
}
return 0;
}
int main(int argc, char* argv[])
{
g_hClear = CreateEvent(NULL, FALSE, FALSE, NULL);
g_hSet = CreateEvent(NULL, FALSE, TRUE, NULL);
HANDLE hThread[2];
hThread[0] = ::CreateThread(NULL, 0, ThreadProduct, NULL, 0, NULL);
hThread[1] = ::CreateThread(NULL, 0, ThreadConsumer, NULL, 0, NULL);
WaitForMultipleObjects(2, hThread, TRUE, INFINITE);
CloseHandle(hThread[0]);
CloseHandle(hThread[1]);
CloseHandle(g_hSet);
CloseHandle(g_hClear);
return 0;
}
===================
Then we can use mutex:
#include<cstdio>
#include<windows.h>
HANDLE hMutex;
int g_Max = 10;
int g_Number = 0;
DWORD WINAPI ThreadProduct(LPVOID pM)
{
for (int i = 0; i < g_Max; i++)
{
WaitForSingleObject(hMutex, INFINITE);//
if (g_Number == 0)
{
g_Number = 1;
DWORD id = GetCurrentThreadId();
printf("Producer%dput stuff in%dmarket\n", id, g_Number);
}
else
{
printf("-------------------------\n");
i--;
}
ReleaseMutex(hMutex);
}
return 0;
}
DWORD WINAPI ThreadConsumer(LPVOID pM)
{
for (int i = 0; i < g_Max; i++)
{
WaitForSingleObject(hMutex, INFINITE);
if (g_Number == 1)
{
g_Number = 0;
DWORD id = GetCurrentThreadId( );
printf("-----Consumer%dtake out stuff in%dmarket\n", id, g_Number);
}
else
{
printf("+++++++++++++++++++++\n");
i--;
}
ReleaseMutex(hMutex);
}
return 0;
}
int main(int argc ,char*argv[])
{
hMutex = CreateMutex(NULL, FALSE, NULL);
HANDLE hThread[2];
hThread[0] = ::CreateThread(NULL, 0, ThreadProduct, NULL, 0, NULL);
hThread[1] = ::CreateThread(NULL, 0, ThreadConsumer, NULL, 0, NULL);
WaitForMultipleObjects(2, hThread, TRUE, INFINITE);
CloseHandle(hThread[0]);
CloseHandle(hThread[1]);
CloseHandle(hMutex);
return 0;
}
===================
If you have problems with the code, you can ask me anytime.
Thank you.
Tong
Hi, @Tong Xu - MSFT
Thank you for the answer. I will read carefully from your code and Implement it on my code.
However, is there any way for existing thread ( int main() { /* ... */ } ) to communicate with the other thread, instead of creating two threads?
Hi! @thebluetropics
Thank you for adopting my code.
You said existing thread to communicate with the other thread. That is thread communication of Cross-process.
Which means, Thread X belonging to A Process communicate with Thread Y belonging to B Process.
I can show you a sample:
#include<windows.h>
#include<cstdio>
int main(int argc, char* argv[])
{
HANDLE g_hMutex = CreateMutex(NULL, FALSE, "XYZ");
WaitForSingleObject(g_hMutex, INFINITE);//condition of own mutex:1.signal 2.own thread
for (int i = 0; i < 10; i++)
{
//(1000);
if(i==5)
ExitProcess(0);//if thread shutdown by accident, mutex avoid waiting for a long time
printf("X thread of A process : % d \n",i);
}
ReleaseMutex(g_hMutex);//release
return 0;
}
=========================
Line 11, web does not allow sent Sleep function, please modify it by yourself
Run this program twice, you will find out process which run after that must wait for the first process to finish running then it can run.
it just likes you and i using same car, only you finish using the car and give it to me, then i can use the car, isn't it?
You can ask me anytime, I will reply you as soon as possible.
Tong
@TongXu
Sorry, I don't meant to do cross-process communication, my bad.
Your code in your answer is what I want, however, it creates two threads instead of creating just a single thread. So, there should be two threads in a process instead of three threads.
In short, I need a way for a process's main thread to communicate with their created thread.
WaitForSingleObject() blockes everything after calling this function.
However, your code is fine.
Hi, @thebluetropics
I've described it through the above code, of course It just gives an idea, after all at first you only told me that two threads were communicating.
Actually, you also can create only thread to use it by main( ) and ThreadProc( ).Exactly how to implement it is up to you.
Thank you for your feedback on the use of my code！
Tong