从不同进程中的另一个线程暂停/恢复一个线程或进程

Question

In one of my projects I create multiple processes (which are sub projects that I developed) from my main project as CREATE_SUSPENDED and storing their handles in a global array but; when I want to resume it with ResumeThread function I get ERROR_INVALID_HANDLE error code.

The MSDN specifies that the thread must have THREAD_SUSPEND_RESUME access right and I couldn't find how to set it.

Do those handles are only valid on its process space and how can I suspend/resume a thread or process from another process with all the handles I stored?

Note: I know synchronization objects may have a use here but is it the only and only way?

One more issue is; how to obtain handle of a thread created by my ProcessClass from the main process, which also created that ProcessClass?

Here is a portion of the code

ProcessClass

void ProcessClass::Start(){       
    STARTUPINFO si;
    PROCESS_INFORMATION pi;
    ZeroMemory(&pi, sizeof(pi));
    ZeroMemory(&si, sizeof(si));
    si.cb = sizeof(si);

    BOOL createdProc = CreateProcess(NULL, 
        ProcessExeDir, 
        NULL, 
        NULL, 
        TRUE, 
        CREATE_NEW_CONSOLE | CREATE_SUSPENDED
        , NULL, 
        NULL, 
        &si, 
        &pi); 
    if (createdProc == FALSE)
    {
        UINT32 errorCode = GetLastError();        
    }
    else
    {
        DWORD affinity;
        affinity = 0x000000010 << (5);
        SetProcessAffinityMask(pi.hProcess, affinity);

        ProcessHandler = pi.hProcess;
        ProcessInfoPtr->ProcHandle = ProcessHandler;

        // I can need this handle
        // CloseHandle(pi.hThread);
    }
}

// ProcessInPtr is defines as ProcessInfoStc* in the header
ProcessInfoStc* ProcessClass::GetProcessInfoPtr() {
    return ProcessInfoPtr;
}

In the Main Project:

int main() {
   // this is declared as ManageProcesses(const ProcessInfoStcPtr& processes)
    ManageProcesses(ProcessInfoArray);
    return 0;
}

In ManageProcess function which is in the same lib project with the ProcessClass and following structure definitions:

ProcessClass processObj = new ProcessClass();
processObj->Start();
...
HANDLE pHandle = processObj->GetProcessInfoPtr()->ProcHandle;
//! pHandle is is same with the created process handle as I debug
ResumeThread(pHandle); 
DWORD error = GetLastError(); // RETURNS INVALID HANDLE

And the Structure to store process is also in main process

ProcessInfoStc {
    HANDLE ProcHandle ,
    DWORD ProcId..
 }
 ProcessInfoStc ProcessInfoArray[10] = {
     {
        0,0...
     },...
 }
 typedef ProcessInfoStc* ProcessInfoStcPtr;

Answer 1

In one of my projects I create multiple processes (which are sub projects that I developed) from my main project as CREATE_SUSPENDED and storing their handles in a global array but; when I want to resume it with ResumeThread function I get ERROR_INVALID_HANDLE error code.

That is because you are passing a process handle ( pi.hProcess ) to ResumeThread() . You cannot resume a process using ResumeThread() . As its name implies, you need to pass it a thread handle instead ( pi.hThread ).

The MSDN specifies that the thread must have THREAD_SUSPEND_RESUME access right and I couldn't find how to set it.

You already have it, per the documentation:

Creating Processes

The thread and process handles are created with full access rights , although access can be restricted if you specify security descriptors.

how to obtain handle of a thread created by my ProcessClass from the main process, which also created that ProcessClass ?

You are not currently storing the thread handle anywhere, you do can't retrieve it. Update your ProcessInfoStc struct to store both HANDLE s that CreateProcess() returns. And don't forget to close both of them when you are done using them.

Answer 2

I would recommend against stopping/resuming threads using the OS or threading library low level APIs, unless you are writing a thread scheduling algorithm (but then your code should reside in the kernel). In a modern OS and correctly written multi-threaded application threads in a waiting state consume almost no resources, so there should really be no reason to intervene there. That would be the reason why you will unlikely see thread.suspend() and thread.resume() in practical code examples nowdays.

I would just build an application the way that threads would be polling (via an abstraction of IOLoop, Dispatcher, Executor, Actor, etc.) on IO selector(s), task queue(s), and only wake up and do something when there's a work to be done.