第5章 作业和进程池(1)

#include <stdio.h>
#include <windows.h>
#include <tchar.h>
#include <strsafe.h>
#include <malloc.h>  //for _alloca函数
#include <locale.h>

//获取作业中当前的进程ID集
void EnumProcessIdsInJob(HANDLE hJob)
{
    //先假设作业中的进程不会超过10个
    const int MAX_PROCESS_IDS = 10;

    //计算结构体和ID集所需的空间大小
    DWORD cb = sizeof(JOBOBJECT_BASIC_PROCESS_ID_LIST) +
        (MAX_PROCESS_IDS - 1)*sizeof(DWORD);

    //分配内存，注意_alloca是在栈（而不是堆上分配的，所以不需要释放）
    PJOBOBJECT_BASIC_PROCESS_ID_LIST pjobpil =
        (PJOBOBJECT_BASIC_PROCESS_ID_LIST)_alloca(cb);

    //估计最多的进程数
    pjobpil->NumberOfAssignedProcesses = MAX_PROCESS_IDS;

    //查询
    QueryInformationJobObject(hJob, JobObjectBasicProcessIdList, pjobpil, cb, &cb);

    //显示进程ID集
    for (DWORD x = 0; x < pjobpil->NumberOfProcessIdsInList; x++)
    {
        _tprintf(TEXT("process%d(ID=%d)n"),x+1,pjobpil->ProcessIdList[x]);
    }

}

//利用作业对象对进程进程管理的演示
void StartRestrictedProcess()
{
    //检查进程是否己经关联到一个作业对象中了
    //如果己经关联，就没办法再换到另一个作业对象中去
    BOOL bInJob = FALSE;
    IsProcessInJob(GetCurrentProcess(), NULL, &bInJob);
    if (bInJob)
    {
        printf("Process already in a jobn");
        return;
    }

    //创建作业内核对象
    HANDLE hjob = CreateJobObject(NULL, TEXT("MyRestrictedProcessJob"));

    //在作业中放入线程对象的一些限制规则
    //首先，设置基本限制
    JOBOBJECT_BASIC_LIMIT_INFORMATION jobli = { 0 };

    //进程总是运行在“空闲”优先级
    jobli.PriorityClass = IDLE_PRIORITY_CLASS;

    //该作业对象在用户模式下不能超过1秒的CPU时间（课本这里错了吧，应该1ms)
    //jobli.PerJobUserTimeLimit.QuadPart = 2000* 10000; //多少个tick（1tick=100ns）
    //jobli.PerProcessUserTimeLimit.QuadPart = 1*10000; //1ms
    jobli.PerJobUserTimeLimit.QuadPart = 1000*10000I64;
                                    //10000tick=10000*100ns=1ms
    //这里只增加了以上两个限制
    jobli.LimitFlags = JOB_OBJECT_LIMIT_PRIORITY_CLASS |
                       JOB_OBJECT_LIMIT_JOB_TIME;
    SetInformationJobObject(hjob, JobObjectBasicLimitInformation,
                            &jobli, sizeof(jobli));
    //其次，设置UI限制
    JOBOBJECT_BASIC_UI_RESTRICTIONS jobuir;
    jobuir.UIRestrictionsClass = JOB_OBJECT_UILIMIT_NONE; //初始化为0

    //进程不能访问用户对象（如窗口句柄）
    jobuir.UIRestrictionsClass |= JOB_OBJECT_UILIMIT_HANDLES;
    //进程不能关闭系统
    jobuir.UIRestrictionsClass |= JOB_OBJECT_UILIMIT_EXITWINDOWS;

    SetInformationJobObject(hjob, JobObjectBasicUIRestrictions,
                            &jobuir, sizeof(jobuir));

    //创建子进程并加入作业对象中
    //    Note:进程被创建后，其线程要立刻挂起，在加入作业对象前不能执行
    //         任何代码，这是作业对象的要求。否则，进程执行的那部分代码
    //         可能就不受作业对象的限制。

    STARTUPINFO si = { sizeof(si) };
    PROCESS_INFORMATION pi;
    TCHAR szCmdLine[8];
    _tcscpy_s(szCmdLine, _countof(szCmdLine), TEXT("CMD"));

    BOOL bResult = CreateProcess(NULL, szCmdLine, NULL, NULL, FALSE,
                                 CREATE_SUSPENDED | CREATE_NEW_CONSOLE /*| CREATE_BREAKAWAY_FROM_JOB8*/,
                                 NULL,NULL,&si,&pi);

    //将子进程加入到作业对象中
    //     注意：当创建子进程时，子进程会自动加入到父进程所在的作业对象
                 
    AssignProcessToJobObject(hjob, pi.hProcess);

    //现在可以恢复子进程的主线程,开始执行代码
    ResumeThread(pi.hThread);
    CloseHandle(pi.hThread);

    //枚举作业对象中的进程值ID
    EnumProcessIdsInJob(hjob);

    //等待子进程结束或作业对象所分配的CPU时间被用完
    HANDLE h[2];
    h[0] = pi.hProcess;
    h[01] = hjob;

    /*WaitForMultipleObjects
    1. nCount，DWORD类型，用于指定句柄数组的数量
    2. lphObjects，Pointer类型，用于指定句柄数组的内存地址
    3. fWaitAll，Boolean类型，True表示函数等待所有指定句柄的Object有信号为止
    4. dwTimeout，DWORD类型，用于指定等待的Timeout时间，单位毫秒，可以是INFINITE

    返回值：
    如果fWaitAll为TRUE，则返回值表明所有指定对象的状态信号
    如果fWaitAll为FALSE，则返回值-WAIT_OBJECT_0 表示lphObjects数组相应的对象变成有信号
    */
    DWORD dw = WaitForMultipleObjects(2, h, FALSE, INFINITE);
    switch (dw - WAIT_OBJECT_0)
    {
    case 0:
        printf("The process has terminated...n");
        break;

    case 1:
        printf("All of the job's allotted CPU time was used...n");
        break;
    }

    FILETIME  CreationTime;
    FILETIME  EXitTime;
    FILETIME  KernelTime;
    FILETIME  UserTime;
    TCHAR szInfo[MAX_PATH];

    GetProcessTimes(pi.hProcess, &CreationTime, &EXitTime,
                    &KernelTime, &UserTime);

    StringCchPrintf(szInfo, _countof(szInfo), 
                    TEXT("Kernel = %u | User = %un"),
                     KernelTime.dwLowDateTime/10000,
                     UserTime.dwLowDateTime / 10000);
    CloseHandle(pi.hProcess);
    CloseHandle(hjob);

    _tprintf(szInfo);

    _tsystem(_T("PAUSE"));
    return;
}

int main()
{
    _tsetlocale(LC_ALL, TEXT("chs"));
    StartRestrictedProcess();
    return 0;
}