window的job(作业) 用于管理一个进程集合，是job中的所有进程执行相同的操作。

  1. 作业可以看成一个进程池；Job
  2. 一个进程一旦加入一个作业，就不能再加入另外一个作业。
  3. 一个进程一旦加入一个作业，就不能再退出来。
  4. 作业也是一个内核对象。
  5. 如果一个进程加入了一个作业，那么这个进程使用CreateProcess创建的所有子进程，自动加入到父进程加入的作业中。否则，调用CreateProcess函数的时候，需要在createprocess的flag参数设置为CREATE_BREAKAWAY_FROM_JOB标识。

一直以来对这个东西总是搞不清楚，看了几遍Windows核心编程后，总算是有一点点感觉了，欢迎高手对我不正确的理解拍砖指正。
Job可以被理解为进程的容器，而它又不是单纯的容器，按照书本上所讲的，Job是一个沙盒，它可以为在它里面运行的进程增加一系列的限制。包括每一个进程或者整个Job能够使用的User mode CPU时间，每一个进程或者整个Job最多能使用的内存，Job内的进程能否访问到Job外的用户对象（例如窗口，画刷），能否退出Windows，能否访问剪切板等等。当限制设定之后，我们就可以创建一个进程，并将它放置到Job之中。
需要注意的是：

  • Job对象即使引用数到了0也不会立刻释放，它会等到Job内所有的进程都结束了再释放，但是，在这种情况下，Job的名称将会失效，不能再通过Job的名称和Job的句柄来向Job中增加新的进程。
  • Job可以设置当前可运行进程最大数量。当超过这个最大数量时，任何新进程都将被立刻终止（Terminate）。
  • Job可以在同一进程优先级下设定调度的微调值（SchedulingClass）。微调值高的Job中的线程比微调值低的获得更多的CPU时间。
  • Job可以限制对用户对象以及Windows界面的访问，例如不许退出窗口，不能访问剪切板等。这意味着Job内的进程无法获取到Job外进程的对象，比如HWND，但是Job外的进程可以获得Job内进程的对象。
  • 对Job设定了OBOBJECT_SECURITY_LIMIT_INFORMATION后，该设定不能被取消。
  • 新建的进程最好使用CREATE_SUSPEND Flag，这样新进程启动后在加入到Job之前它都无法运行，从而避免新进程可以逃出沙盒。在加入到Job之后，继续运行进程即可。

详见如下文档：Windows Job简介

创建一个作业

  1. //创建一个job
  2.     HANDLE hJob1 = CreateJobObject(NULL, L"作业名字");
  4.     _tprintf(L"hJob1 = %X GetLastError = %d\n", hJob1, GetLastError());

创建一个进程

  1.     //初始化进行相关参数
  2.     STARTUPINFO si;
  3.     PROCESS_INFORMATION pi;
  5.     ZeroMemory(&si, sizeof(si));
  6.     si.cb = sizeof(si);
  7.     ZeroMemory(&pi, sizeof(pi));    
  8.     // Start the child process. 
  9.     if (!CreateProcess(L"x32.exe",   // No module name (use command line)
  10.         NULL,        // Command line
  11.         NULL,           // Process handle not inheritable
  12.         NULL,           // Thread handle not inheritable
  13.         NULL,          // Set handle inheritance to FALSE
  14.         0,              // No creation flags
  15.         NULL,           // Use parent's environment block
  16.         NULL,           // Use parent's starting directory 
  17.         &si,            // Pointer to STARTUPINFO structure
  18.         &pi)           // Pointer to PROCESS_INFORMATION structure
  19.         )
  20.     {
  21.         _tprintf(L"CreateProcess failed (%d).\n", GetLastError());
  22.         return 0;
  23.     }

将进程加入到作业中

将进程加入到作业中的函数是AssignProcessToJobObject
该函数有两个参数一个是hJob:要将进程hProcess加入的那个作业的句柄，另一个是Process:要加入到作业中的进程句柄
返回值为 return:成功返回1，否则返回0

  1.     /*
  3.     BOOL WINAPI AssignProcessToJobObject(
  4.   __in  HANDLE hJob,
  5.   __in  HANDLE hProcess
  6. );
  8.     hJob:        要将进程hProcess加入的那个作业的句柄
  9.     Process:    要加入到作业中的进程句柄
  10.     return:        成功返回1，否则返回0
  12. */
  13. //将进程添加到job中
  14.     re = AssignProcessToJobObject(hJob1, GetCurrentProcess());
  16.     _tprintf(L" re  =  %d \n", re);

检查进程是否已经存在于作业中IsProcessInJob

IsProcessInJob 函数包括三个参数
ProcessHandle：需要检查确认的进程句柄 A。
JobHandle：作业句柄 B
Result：检查结果，如果是1，那么说明进程A已经被放入做也B，否则进程A没有被放到作业B中。
Return：成功，返回1，否则返回1

  1.     re = IsProcessInJob(GetCurrentProcess(), NULL, &Result);    //检查进程是否在job中
  3.     _tprintf(L" re  =  %d  Result = %d\n", re, Result);

完整的代码

  4. #include<Windows.h>
  5. #include<tchar.h>
  7. int _tmain()
  8. {
  9.     /*
  10.     判断一个进程是否已经加入了一个作业的函数是：IsProcessInJob;
  11.     BOOL WINAPI IsProcessInJob(
  12.   __in      HANDLE ProcessHandle,
  13.   __in_opt  HANDLE JobHandle,
  14.   __out     PBOOL Result
  15. );
  17.     ProcessHandle:    要判断的进程句柄；
  18.     JobHandle：        看看进程是否加入到JobHandle这个作业中；
  19.     Result：            判断结果。
  20.     */
  22.     //创建一个job
  23.     HANDLE hJob1 = CreateJobObject(NULL, L"hello");
  25.     _tprintf(L"hJob1 = %X GetLastError = %d\n", hJob1, GetLastError());
  27.     HANDLE hJob2 = CreateJobObject(NULL, L"hello");
  29.     _tprintf(L"hJob2 = %X GetLastError = %d\n", hJob2, GetLastError());
  31.     /*
  33.     BOOL WINAPI IsProcessInJob(
  34.   __in      HANDLE ProcessHandle,
  35.   __in_opt  HANDLE JobHandle,
  36.   __out     PBOOL Result
  37. );
  40.     ProcessHandle    需要检查确认的进程句柄 A。
  41.     JobHandle        作业句柄 B
  42.     Result            检查结果，如果是1，那么说明进程A已经被放入做也B，否则进程A没有被放到作业B中。
  44.     Return            成功，返回1，否则返回1
  47. */
  49.     DWORD re;
  51.     BOOL Result;
  53.     //检查进程是否在job中
  54.     re = IsProcessInJob(GetCurrentProcess(), NULL, &Result);    //检查进程是否在job中
  56.     _tprintf(L" re  =  %d  Result = %d\n", re, Result);
  58.     /////////////////////////////////////////////////////////
  59.     //初始化进行相关参数
  60.     STARTUPINFO si;
  61.     PROCESS_INFORMATION pi;
  63.     ZeroMemory(&si, sizeof(si));
  64.     si.cb = sizeof(si);
  65.     ZeroMemory(&pi, sizeof(pi));
  67.     /*
  69.     BOOL WINAPI AssignProcessToJobObject(
  70.   __in  HANDLE hJob,
  71.   __in  HANDLE hProcess
  72. );
  74.     hJob:        要将进程hProcess加入的那个作业的句柄
  75.     Process:    要加入到作业中的进程句柄
  76.     return:        成功返回1，否则返回0
  78. */
  79. //将进程添加到job中
  80.     re = AssignProcessToJobObject(hJob1, GetCurrentProcess());
  82.     _tprintf(L" re  =  %d \n", re);
  84.     re = IsProcessInJob(GetCurrentProcess(), NULL, &Result);
  86.     _tprintf(L" re  =  %d  Result = %d\n", re, Result);
  89.     // Start the child process. 
  90.     if (!CreateProcess(L"x32.exe",   // No module name (use command line)
  91.         NULL,        // Command line
  92.         NULL,           // Process handle not inheritable
  93.         NULL,           // Thread handle not inheritable
  94.         NULL,          // Set handle inheritance to FALSE
  95.         0,              // No creation flags
  96.         NULL,           // Use parent's environment block
  97.         NULL,           // Use parent's starting directory 
  98.         &si,            // Pointer to STARTUPINFO structure
  99.         &pi)           // Pointer to PROCESS_INFORMATION structure
  100.         )
  101.     {
  102.         _tprintf(L"CreateProcess failed (%d).\n", GetLastError());
  103.         return 0;
  104.     }
  105.     /////////////////////////////////////////
  107.     re = IsProcessInJob(pi.hProcess, hJob1, &Result);
  109.     _tprintf(L" re  =  %d  pi.hProcess Result = %d\n", re, Result);
  111.     _gettchar();
  113.     CloseHandle(hJob1);
  114.     CloseHandle(hJob2);
  115.     CloseHandle(pi.hProcess);
  116.     CloseHandle(pi.hThread);
  118.     return 0;
  120. }