is any plugin need to beadded for using multithreading?

[kmb828]

Hi,
I was new to threading concepts. Can I know is any plugin needed to be add for using threads?
I was using MS visual studio 2010.

[G309216C]

What! Are you kidding?

There is no plugin to be added for using threads. A simple Proof-Of-Concept code I prepared:

#include<Windows.h>
#include<iostream>
DWORD hello()
{
	std::cout<<"Thread";
	return 0;
}
int main()
{
	CreateThread(0,0,(LPTHREAD_START_ROUTINE)hello,(LPVOID)0,0,0);
	std::cin.get();
}

Just compile & run this POC code above in Visual Studio 2010 and it will work. There is no plugin needed.

Thanks

[plexus]

No, not really. At least I wouldn't call it "plugin".
Multithreading is supported by various Microsoft libraries.

.Net:
http://msdn.microsoft.com/en-us/library/system.threading.thread.aspx

MFC:
http://msdn.microsoft.com/en-us/library/48xz4yz9.aspx

Win32:
http://msdn.microsoft.com/en-us/library/ms682453%28VS.85%29.aspx


They all work more or less the same way. There are also some third party libraries that support multithreading. But for starters the MS libs should work.

[andywestken]

@SpaceWorm

A LPTHREAD_START_ROUTINE cast like that should never be used with CreateThread, not even in a toy program.

If I remove the cast I get

error C2664: 'CreateThread' : cannot convert parameter 3 from
 'DWORD (__cdecl *)(void)' to 'LPTHREAD_START_ROUTINE

An error, not a warning!

This is the right way to code it is (inc. two stylistic tweaks):

#include<Windows.h>
#include<iostream>
DWORD WINAPI hello(void* pv) // can also use LPVOID
{
	std::cout<<"Thread";
	return 0;
}
int main()
{
	CreateThread(NULL,0,hello,NULL,0,NULL);
	std::cin.get();
	return 0;
}

(For some reason people frequently use LPVOID and void* interchangeably, but not DWORD. And using NULL makes it cleared it's a pointer; returning 0 from main is a good habit (even though the compiler adds "return 0;" if you're too lazy to do so.)

You should never cast a function pointer (unless forced to!) as you can cause problems (note: some info is included for passing, less experienced readers.)

- First of all, your saying this function takes 1 parameter, when it doesn't, so the wrong number of parameter will be pucsed onto the stack when it calls.

- Then you're saying it's a __stdcall function (WINAPI is a #define of __stdcall) when it's __cdecl (usually, this is the default for most C++ and C compilers), so the stack clean up will be messed up.

Andy

PS A more complete, illustrative example:

Edit Also see Microdsoft example in: "Creating Threads"
http://msdn.microsoft.com/en-us/library/windows/desktop/ms682516%28v=vs.85%29.aspx

#include<windows.h>
#include<iostream>

// Recovers user data (number of loops wanted)
// from start parameter and runs loop.
//
// NOTE this code is passing the address of a local variable
// in main. It is safe to do so here as main() is waiting for this
// thread and so the variable will be valid (i.e. exist) for the
// whole lifetime of the thread.
//
// In the general case, memory for the thread parameter
// should be allocated on the heap using new or malloc and then
// left for the thread to delete when it's done with the data
// (with delete or free.) Or a similar mechanism.
DWORD WINAPI hello_thread_routine(void* param)
{
    const int loop_period_msecs = 250;

    // recover data from thread parameter
    const int loop_count = *((const long*)param);
    for(int i = 0; i < loop_count; ++i)
    {
        std::cout << "Thread : loop #" << (i + 1)
                  << " of " << loop_count << std::endl;
        Sleep(loop_period_msecs);
    }
    std::cout << "Thread : done" << std::endl;

    return 0;
}

// main creates thread suspended and then uses ResumeThread
// to prevent output from main and thread from getting mixed up.
// Threads are often created non-suspended.
int main()
{
    const int loop_count = 10;

    std::cout << "main : Create thread" << std::endl;
    HANDLE hThread = CreateThread( NULL,                // NULL = use default security
                                   0,                   // 0 = use default stack size
                                   hello_thread_routine,
                                   (LPVOID)&loop_count, // start param
                                   CREATE_SUSPENDED,    // flags
                                   NULL );              // don't want thread id

    std::cout << "main : Wait for thread" << std::endl;
    ResumeThread(hThread); // see note above
    WaitForSingleObject(hThread, INFINITE);

    std::cout << "main : Close thread handle" << std::endl;
    CloseHandle(hThread); // should close handle

    std::cout << "main : <return> to continue...";
    std::cin.get();

    return 0;
}

[G309216C]

Thanks! Andy, but mostly I always have some type of paramter included so I am used to overfilling the stack, but you can always break the stack using DWORD and DWORD64 to generate a wrong 'pop word ptr[]'.

I always break the stack next. This should mean mine may need a bit more code but will completely break the stack that way when including more functions more than 4+ then the stack start again right?

but for x64 it could be a problem then, your solution would be great!

Also seems like you are knowledgeable in Windows API can you please help me with: http://www.cplusplus.com/forum/windows/103341/


I must admit, I always create my own style of programming mostly different from others.
Thanks!

[andywestken]

@SpaceWorm

Also seems like you are knowledgeable in Windows API can you please help me with: http://www.cplusplus.com/forum/windows/103341/

Sorry -- I did see your "IE Injection Failure" post, but I don't know a lot about DLL injection (I've played with it, but never worked with it.)

[G309216C]

No problem,andy if you do have solution please tell me about it.