精华内容
下载资源
问答
  • Windows多进程编程

    2017-11-14 19:46:00
    一、进程的概念 ... 1、进程的内核对象:即我们通常所讲的PCB(进程控制块),该结构只能由该内核访问,他是操作系统用来管理进程的一个数据结构,操作系统通过该数据结构来感知和管理进程;它的成...
    一、进程的概念
           进程是是一个正在运行的程序的实例(飘~~~),是系统分配资源的单位(线程是执行的单位),包括内存,打开的文件、处理机、外设等,进程由两部分组成:
          1、进程的内核对象:即我们通常所讲的PCB(进程控制块),该结构只能由该内核访问,他是操作系统用来管理进程的一个数据结构,操作系统通过该数据结构来感知和管理进程;它的成员负责维护进程的各种信息,包括进程的状态(创建、就绪、运行、睡眠、挂起、僵死等)、消息队列等;同时也是系统用来存放关于进程的统计信息的地方。
          注:具体结构参照Linux的task_struct数据结构。
          2、进程的地址空间:包含所有可执行模块或DLL模块的代码和数据,以及动态内存分配的空间,如线程堆栈和堆分配的空间。共有4G,0-2G为用户区,2-4G为系统区。
    二、进程的创建过程
          1、系统创建进程内核对象(PCB进程控制块)。
          2、系统为新进程创建虚拟地址空间,帮将可执行文件或任何必要的DLL文件的代码和数据加载到该进程的地址空间。
          3、系统为新进程的主线程创建一个线程内核对象(TCB线程控制块)。
          4、通过执行C/C++运行期启动代码,该主线程开始运行。
          注:在Windows环境下,尽量用多线程而不是多进程。
    三、与进程相关的API
    1、创建进程
                BOOL CreateProcess(
                        PCTSTR      psApplicationName, //可执行文件的名字
                        PTSTR      pszCommandLine, //命令行字符串
                        PSECURITY_ATTRIBUTES psaProcess,   //进程对象的安全性
                        PSECURITY_ATTRIBUTES psaThread,   //线程对象的安全性
                        BOOL      bInheritHandles, //句柄可继承性
                        DWORD      fdwCreate,   //标识符(优先级)
                        PVOID      pvEnvironment, //指向环境字符串
                        PCTSTR      pszCurDir,   //子进程当前目录
                        PSTARTUPINFO    psiStartInfo,
                        PPROCESS_INFORMATION ppiProcInfo);   //进程线程句柄及ID
    2、打开进程
                HANDLE OpenProcess(
                        DWORD dwDesiredAccess, //访问安全属性
                        BOOL bInheritHandle, //继承属性
                        DWORD hProcessId);   //进程ID
                注:获取hPronessId指定的进程的内核对象的句柄
    3、终止进程
    (1)、主线程的进入点函数返回
    (2)、进程自己终止自己
                  VOID ExitProcess(
                            UINT fuExitCode); //退出代码
    (3)、终止自身进程或其他进程
                  BOOL TerminateProcess(
                          HANDLE hProcess, //进程句柄
                          UINT fuExitCode); //退出代码
    三、与进程相关的API
    4、获取进程的可执行文件或DLL对应的句柄
                  HMODULE GetModuleHandle(
                          PCTSTR pszModule); //模块名称
                  注:当参数传NULL时获取的是进程的地址空间中可执行文件的基地址。
    5、获取与指定窗口关联在一起的一个进程和线程标识符
                  HANDLE GetWindowThreadProcessId(
                          HWND hWnd,    //窗口句柄
                          LPDWORD lpdwProcessId); //与该窗口相关的进程ID
    6、获取进程的运行时间
                  Bool GetProcessTimes(
                          HANDLE hProcess,   //进程句柄
                          PFILETIME pftCreationTime, //创建时间
                          PFILETIME pftExitTime, //退出时间
                          PFILETIME pftKernelTime, //内核时间
                          PFILETIME pftUserTime); //用户时间
                  注:返回的时间适用于某个进程中的所有线程(甚至已经终止运行的线程)。
    7、获取当前进程的一个伪句柄
                  HANDLE GetCurrentProcess();
                   注:该函数获取当前进程的伪句柄,通常情况值为-1,只能标识当前进程内核对象,
                          可以复制,但不可继承。不必调用CloseHandle()函数来关闭这个句柄。
    8、将进程的伪句柄转换为实句柄
                  HANDLE DuplicateHandle(
                          GetCurrentProcess(),
                          GetCurrentProcess(),
                          GetCurrentProcess(),
                          &hProcess,
                          0,
                          FALSE ,
                          DUPLICATE_SAME_ACCESS);
    9、获取当前进程ID
                  DWORD GetCurrentProcessId();
    10、获取进程优先级
                  DWORD GetPriorityClass(
                       HANDLE hProcess);
    11、修改进程的优先级类
                  BOOL SetPriorityClass(
                         HANDLE hProcess, //进程句柄
                         DWORD fdwPriority); //相对进程优先级
                  注1:相对线程优先级
                         实时: REALTIME_PRIORITY_CLASS
                         高: HIGH_PRIORITY_CLASS
                         高于正常; ABOVE_NORMAL_PRIORITY_CLASS
                         正常: NORMAL_PRIORITY_CLASS
                         低于正常: BELOW_NORMAL_PRIORITY_CLASS
                         空闲: IDLE_PRIORITY_CLASS
                  注2:只要拥有进程的句柄和足够的权限,就能够修改系统中运行的任何进程的优
                           先级类。
    12、获取进程句柄计数
                  BOOL GetProcessHandleCount(
                          HANDLE hProcess,   //句柄
                          PDWORD pdwHandleCount); //句柄计数
    13、获取环境块
                  DWORD GetEnvironmentVariable(
                          LPCTSTR lpName, //环境变量的名字
                          LPTSTR lpValue, //存放返回字符串的缓冲区
                          DWORD cchValue); //缓冲区的大小
                  注:返回值为返回字符串的长度,当缓存不足时返回所需字符串的长度
    14、设置环境块
                  BOOL SetEnvironmentVariable(
                          LPCTSTR lpName, //环境变量的名字
                          LPCTSTR lpValue); //存放变量值字符串的缓冲区
     

    本文转自jazka 51CTO博客,原文链接:http://blog.51cto.com/jazka/199769,如需转载请自行联系原作者
    展开全文
  • windows多进程编程

    2013-12-06 01:44:23
    一、进程的概念 进程是是一个正在运行的程序的实例,是系统分配资源的单位(线程是执行的单位),包括内存,打开的文件、处理机、外设等,进程由两部分组成: 1、进程的内核对象:即我们通常所讲的PCB(进程控制块)...
    一、进程的概念
    进程是是一个正在运行的程序的实例,是系统分配资源的单位(线程是执行的单位),包括内存,打开的文件、处理机、外设等,进程由两部分组成:
    1、进程的内核对象:即我们通常所讲的PCB(进程控制块),该结构只能由该内核访问,他是操作系统用来管理进程的一个数据结构,操作系统通过该数据结构来感知和管理进程;它的成员负责维护进程的各种信息,包括进程的状态(创建、就绪、运行、睡眠、挂起、死锁等)、消息队列等;同时也是系统用来存放关于进程的统计信息的地方。
    2、进程的地址空间:包含所有可执行模块或DLL模块的代码和数据,以及动态内存分配的空间,如线程堆栈和堆分配的空间。共有4G,0-2G为用户区,2-4G为系统区。
    二、进程的创建过程
    1、系统创建进程内核对象(PCB进程控制块)。
    2、系统为新进程创建虚拟地址空间,帮将可执行文件或任何必要的DLL文件的代码和数据加载到该进程的地址空间。
    3、系统为新进程的主线程创建一个线程内核对象(TCB线程控制块)。
    4、通过执行C/C++运行期启动代码,该主线程开始运行。
    注:在Windows环境下,尽量用多线程而不是多进程。
    三、与进程相关的API
    1、创建进程
    BOOL CreateProcess(
    PCTSTR psApplicationName, //可执行文件的名字
    PTSTR pszCommandLine, //命令行字符串
    PSECURITY_ATTRIBUTES psaProcess, //进程对象的安全性
    PSECURITY_ATTRIBUTES psaThread, //线程对象的安全性
    BOOL bInheritHandles, //句柄可继承性
    DWORD fdwCreate, //标识符(优先级)
    PVOID pvEnvironment, //指向环境字符串
    PCTSTR pszCurDir, //子进程当前目录
    PSTARTUPINFO psiStartInfo,
    PPROCESS_INFORMATION ppiProcInfo); //进程线程句柄及ID
    2、打开进程
    HANDLE OpenProcess(
    DWORD dwDesiredAccess, //访问安全属性
    BOOL bInheritHandle, //继承属性
    DWORD hProcessId); //进程ID
    注:获取hPronessId指定的进程的内核对象的句柄
    3、终止进程
    (1)、主线程的进入点函数返回
    (2)、进程自己终止自己
    VOID ExitProcess(
    UINT fuExitCode); //退出代码
    (3)、终止自身进程或其他进程
    BOOL TerminateProcess(
    HANDLE hProcess, //进程句柄
    UINT fuExitCode); //退出代码
    三、与进程相关的API
    4、获取进程的可执行文件或DLL对应的句柄
    HMODULE GetModuleHandle(
    PCTSTR pszModule); //模块名称
    注:当参数传NULL时获取的是进程的地址空间中可执行文件的基地址。
    5、获取与指定窗口关联在一起的一个进程和线程标识符
    HANDLE GetWindowThreadProcessId(
    HWND hWnd, //窗口句柄
    LPDWORD lpdwProcessId); //与该窗口相关的进程ID
    6、获取进程的运行时间
    Bool GetProcessTimes(
    HANDLE hProcess, //进程句柄
    PFILETIME pftCreationTime, //创建时间
    PFILETIME pftExitTime, //退出时间
    PFILETIME pftKernelTime, //内核时间
    PFILETIME pftUserTime); //用户时间
    注:返回的时间适用于某个进程中的所有线程(甚至已经终止运行的线程)。
    7、获取当前进程的一个伪句柄
    HANDLE GetCurrentProcess();
    注:该函数获取当前进程的伪句柄,通常情况值为-1,只能标识当前进程内核对象,
    可以复制,但不可继承。不必调用CloseHandle()函数来关闭这个句柄。
    8、将进程的伪句柄转换为实句柄
    HANDLE DuplicateHandle(
    GetCurrentProcess(),
    GetCurrentProcess(),
    GetCurrentProcess(),
    &hProcess,
    0,
    FALSE ,
    DUPLICATE_SAME_ACCESS);
    9、获取当前进程ID
    DWORD GetCurrentProcessId();
    10、获取进程优先级
    DWORD GetPriorityClass(
    HANDLE hProcess);
    11、修改进程的优先级类
    BOOL SetPriorityClass(
    HANDLE hProcess, //进程句柄
    DWORD fdwPriority); //相对进程优先级
    注1:相对线程优先级
    实时: REALTIME_PRIORITY_CLASS
    高: HIGH_PRIORITY_CLASS
    高于正常; ABOVE_NORMAL_PRIORITY_CLASS
    正常: NORMAL_PRIORITY_CLASS
    低于正常: BELOW_NORMAL_PRIORITY_CLASS
    空闲: IDLE_PRIORITY_CLASS
    注2:只要拥有进程的句柄和足够的权限,就能够修改系统中运行的任何进程的优
    先级类。
    12、获取进程句柄计数
    BOOL GetProcessHandleCount(
    HANDLE hProcess, //句柄
    PDWORD pdwHandleCount); //句柄计数
    13、获取环境块
    DWORD GetEnvironmentVariable(
    LPCTSTR lpName, //环境变量的名字
    LPTSTR lpValue, //存放返回字符串的缓冲区
    DWORD cchValue); //缓冲区的大小
    注:返回值为返回字符串的长度,当缓存不足时返回所需字符串的长度
    14、设置环境块
    BOOL SetEnvironmentVariable(
    LPCTSTR lpName, //环境变量的名字
    LPCTSTR lpValue); //存放变量值字符串的缓冲区
    展开全文
  • Windows多进程编程 .

    千次阅读 2013-07-08 23:58:37
    一、进程的概念  进程是是一个正在运行的程序的实例(飘~~~),是系统分配资源的单位(线程是执行的单位),包括内存,打开的文件、处理机、外设等,进程由两部分组成:  1、进程的内核对象:即我们通常所讲的...
    一、进程的概念
           进程是是一个正在运行的程序的实例(飘~~~),是系统分配资源的单位(线程是执行的单位),包括内存,打开的文件、处理机、外设等,进程由两部分组成:
          1、进程的内核对象:即我们通常所讲的PCB(进程控制块),该结构只能由该内核访问,他是操作系统用来管理进程的一个数据结构,操作系统通过该数据结构来感知和管理进程;它的成员负责维护进程的各种信息,包括进程的状态(创建、就绪、运行、睡眠、挂起、僵死等)、消息队列等;同时也是系统用来存放关于进程的统计信息的地方。
          注:具体结构参照Linux的task_struct数据结构。
          2、进程的地址空间:包含所有可执行模块或DLL模块的代码和数据,以及动态内存分配的空间,如线程堆栈和堆分配的空间。共有4G,0-2G为用户区,2-4G为系统区。
    二、进程的创建过程
          1、系统创建进程内核对象(PCB进程控制块)。
          2、系统为新进程创建虚拟地址空间,帮将可执行文件或任何必要的DLL文件的代码和数据加载到该进程的地址空间。
          3、系统为新进程的主线程创建一个线程内核对象(TCB线程控制块)。
          4、通过执行C/C++运行期启动代码,该主线程开始运行。
          注:在Windows环境下,尽量用多线程而不是多进程。
    三、与进程相关的API
    1、创建进程
                BOOL CreateProcess(
                        PCTSTR      psApplicationName, //可执行文件的名字
                        PTSTR      pszCommandLine, //命令行字符串
                        PSECURITY_ATTRIBUTES psaProcess,   //进程对象的安全性
                        PSECURITY_ATTRIBUTES psaThread,   //线程对象的安全性
                        BOOL      bInheritHandles, //句柄可继承性
                        DWORD      fdwCreate,   //标识符(优先级)
                        PVOID      pvEnvironment, //指向环境字符串
                        PCTSTR      pszCurDir,   //子进程当前目录
                        PSTARTUPINFO    psiStartInfo,
                        PPROCESS_INFORMATION ppiProcInfo);   //进程线程句柄及ID
    2、打开进程
                HANDLE OpenProcess(
                        DWORD dwDesiredAccess, //访问安全属性
                        BOOL bInheritHandle, //继承属性
                        DWORD hProcessId);   //进程ID
                注:获取hPronessId指定的进程的内核对象的句柄
    3、终止进程
    (1)、主线程的进入点函数返回
    (2)、进程自己终止自己
                  VOID ExitProcess(
                            UINT fuExitCode); //退出代码
    (3)、终止自身进程或其他进程
                  BOOL TerminateProcess(
                          HANDLE hProcess, //进程句柄
                          UINT fuExitCode); //退出代码
    三、与进程相关的API
    4、获取进程的可执行文件或DLL对应的句柄
                  HMODULE GetModuleHandle(
                          PCTSTR pszModule); //模块名称
                  注:当参数传NULL时获取的是进程的地址空间中可执行文件的基地址。
    5、获取与指定窗口关联在一起的一个进程和线程标识符
                  HANDLE GetWindowThreadProcessId(
                          HWND hWnd,    //窗口句柄
                          LPDWORD lpdwProcessId); //与该窗口相关的进程ID
    6、获取进程的运行时间
                  Bool GetProcessTimes(
                          HANDLE hProcess,   //进程句柄
                          PFILETIME pftCreationTime, //创建时间
                          PFILETIME pftExitTime, //退出时间
                          PFILETIME pftKernelTime, //内核时间
                          PFILETIME pftUserTime); //用户时间
                  注:返回的时间适用于某个进程中的所有线程(甚至已经终止运行的线程)。
    7、获取当前进程的一个伪句柄
                  HANDLE GetCurrentProcess();
                   注:该函数获取当前进程的伪句柄,通常情况值为-1,只能标识当前进程内核对象,
                          可以复制,但不可继承。不必调用CloseHandle()函数来关闭这个句柄。
    8、将进程的伪句柄转换为实句柄
                  HANDLE DuplicateHandle(
                          GetCurrentProcess(),
                          GetCurrentProcess(),
                          GetCurrentProcess(),
                          &hProcess,
                          0,
                          FALSE ,
                          DUPLICATE_SAME_ACCESS);
    9、获取当前进程ID
                  DWORD GetCurrentProcessId();
    10、获取进程优先级
                  DWORD GetPriorityClass(
                       HANDLE hProcess);
    11、修改进程的优先级类
                  BOOL SetPriorityClass(
                         HANDLE hProcess, //进程句柄
                         DWORD fdwPriority); //相对进程优先级
                  注1:相对线程优先级
                         实时: REALTIME_PRIORITY_CLASS
                         高: HIGH_PRIORITY_CLASS
                         高于正常; ABOVE_NORMAL_PRIORITY_CLASS
                         正常: NORMAL_PRIORITY_CLASS
                         低于正常: BELOW_NORMAL_PRIORITY_CLASS
                         空闲: IDLE_PRIORITY_CLASS
                  注2:只要拥有进程的句柄和足够的权限,就能够修改系统中运行的任何进程的优
                           先级类。
    12、获取进程句柄计数
                  BOOL GetProcessHandleCount(
                          HANDLE hProcess,   //句柄
                          PDWORD pdwHandleCount); //句柄计数
    13、获取环境块
                  DWORD GetEnvironmentVariable(
                          LPCTSTR lpName, //环境变量的名字
                          LPTSTR lpValue, //存放返回字符串的缓冲区
                          DWORD cchValue); //缓冲区的大小
                  注:返回值为返回字符串的长度,当缓存不足时返回所需字符串的长度
    14、设置环境块
                  BOOL SetEnvironmentVariable(
                          LPCTSTR lpName, //环境变量的名字
                          LPCTSTR lpValue); //存放变量值字符串的缓冲区
    展开全文
  • 多进程编程Python实现多进程的方式有两种:一种方法是os模块中的fork方法,另一种是使用multiprocessing模块。前者仅适用于LINUX/UNIX操作系统,对Windows不支持,后者则是跨平台的实现方式。第一种方式:使用os...

    一 多进程编程

    Python实现多进程的方式有两种:一种方法是os模块中的fork方法,另一种是使用multiprocessing模块。

    前者仅适用于LINUX/UNIX操作系统,对Windows不支持,后者则是跨平台的实现方式。

    第一种方式:使用os模块中的fork方式实现多进程

    importosif __name__ == '__main__':print 'current Process (%s) start ...'%(os.getpid())

    pid=os.fork()if pid <0:print 'error in fork'

    elif pid ==0:print 'I am child process(%s) and my parent process is (%s)',(os.getpid(),os.getppid())else:print 'I(%s) created a chlid process (%s).',(os.getpid(),pid)

    第二种方式:multiprocessing

    由于GIL的存在,python中的多线程其实并不是真正的多线程,如果想要充分地使用多核CPU的资源,在python中大部分情况需要使用多进程。Python提供了非常好用的多进程包multiprocessing,只需要定义一个函数,Python会完成其他所有事情。借助这个包,可以轻松完成从单进程到并发执行的转换。multiprocessing支持子进程、通信和共享数据、执行不同形式的同步,提供了Process、Queue、Pipe、Lock等组件。

    在UNIX平台上,当某个进程终结之后,该进程需要被其父进程调用wait,否则进程成为僵尸进程(Zombie)。所以,有必要对每个Process对象调用join()方法 (实际上等同于wait)。对于多线程来说,由于只有一个进程,所以不存在此必要性。

    multiprocessing提供了threading包中没有的IPC(比如Pipe和Queue),效率上更高。应优先考虑Pipe和Queue,避免使用Lock/Event/Semaphore/Condition等同步方式 (因为它们占据的不是用户进程的资源)。

    多进程应该避免共享资源。在多线程中,我们可以比较容易地共享资源,比如使用全局变量或者传递参数。在多进程情况下,由于每个进程有自己独立的内存空间,以上方法并不合适。此时我们可以通过共享内存和Manager的方法来共享资源。但这样做提高了程序的复杂度,并因为同步的需要而降低了程序的效率。

    Process.PID中保存有PID,如果进程还没有start(),则PID为None。

    window系统下,需要注意的是要想启动一个子进程,必须加上那句if __name__ == "main",进程相关的要写在这句下面。

    创建进程的类:Process([group [, target [, name [, args [, kwargs]]]]]),target表示调用对象,args表示调用对象的位置参数元组。kwargs表示调用对象的字典。name为别名。group实质上不使用。

    方法:is_alive()、join([timeout])、run()、start()、terminate()。其中,Process以start()启动某个进程。join()方法实现进程间的同步。

    #__author: greg#date: 2017/9/19 23:52

    from multiprocessing importProcessimporttimedeff(name):

    time.sleep(1)print('hello', name,time.ctime())if __name__ == '__main__':

    p_list=[]for i in range(3):

    p= Process(target=f, args=('alvin',))

    p_list.append(p)

    p.start()for i inp_list:

    i.join()print('end')#一个主进程,三个子进程

    #output:#hello alvin Fri Nov 24 19:10:08 2017#hello alvin Fri Nov 24 19:10:08 2017#hello alvin Fri Nov 24 19:10:08 2017#end

    类式调用:

    #__author: greg#date: 2017/9/21 20:02

    from multiprocessing importProcessimporttimeclassMyProcess(Process):def __init__(self):

    super(MyProcess, self).__init__()#self.name = name

    defrun(self):

    time.sleep(1)print ('hello', self.name,time.ctime())if __name__ == '__main__':

    p_list=[]for i in range(3):

    p=MyProcess()

    p.start()

    p_list.append(p)for p inp_list:

    p.join()print('end')#output:#hello MyProcess-1 Fri Nov 24 19:12:17 2017#hello MyProcess-2 Fri Nov 24 19:12:17 2017#hello MyProcess-3 Fri Nov 24 19:12:17 2017#end

    显示进程ID号:

    #__author: greg#date: 2017/9/21 20:16

    from multiprocessing importProcessimportosimporttimedefinfo(title):print(title)print('module name:', __name__)print('parent process:', os.getppid())#父进程号

    print('process id:', os.getpid())#进程号

    deff(name):

    info('\033[31;1mfunction f\033[0m')print('hello', name)if __name__ == '__main__':

    info('\033[32;1mmain process line\033[0m')

    time.sleep(10)

    p= Process(target=info, args=('bob',))

    p.start()

    p.join()#output:#main process line#module name: __main__#parent process: 1548 pycharm的进程号#process id: 8416 Python进程号#bob#module name: __mp_main__#parent process: 8416 Python进程号#process id: 5556 info进程号

    二 Process类

    构造方法:

    Process([group [, target [, name [, args [, kwargs]]]]])

    group: 线程组,目前还没有实现,库引用中提示必须是None;

    target: 要执行的方法;

    name: 进程名;

    args/kwargs: 要传入方法的参数。

    实例方法:

    is_alive():返回进程是否在运行。

    join([timeout]):阻塞当前上下文环境的进程程,直到调用此方法的进程终止或到达指定的timeout(可选参数)。

    start():进程准备就绪,等待CPU调度

    run():strat()调用run方法,如果实例进程时未制定传入target,这star执行t默认run()方法。

    terminate():不管任务是否完成,立即停止工作进程

    属性:

    authkey

    daemon:和线程的setDeamon功能一样

    exitcode(进程在运行时为None、如果为–N,表示被信号N结束)

    name:进程名字。

    pid:进程号。

    三 进程间通讯

    不同进程间内存是不共享的,要想实现两个进程间的数据交换,可以用以下方法:

    Queues 用来在多个进程间通信:

    1. 阻塞模式

    importqueueimporttime

    q= queue.Queue(10) #创建一个队列

    start=time.time()for i in range(10):

    q.put('A')

    time.sleep(0.5)

    end=time.time()print(end-start)

    这是一段极其简单的代码(另有两个线程也在操作队列q),我期望每隔0.5秒写一个'A'到队列中,但总是不能如愿:

    间隔时间有时会远远超过0.5秒。

    原来,Queue.put()默认有 block = True 和 timeout两个参数。

    源码:def put(self, item, block=True, timeout=None):

    当 block = True 时,写入是阻塞式的,阻塞时间由 timeout确定。

    当队列q被(其他线程)写满后,这段代码就会阻塞,直至其他线程取走数据。

    Queue.put()方法加上 block=False 的参数,即可解决这个隐蔽的问题。

    但要注意,非阻塞方式写队列,当队列满时会抛出 exception Queue.Full 的异常。

    #__author: greg#date: 2017/9/21 22:27

    from multiprocessing importProcess, Queuedeff(q,n):

    q.put([42, n, 'hello'])print('subprocess id',id(q))if __name__ == '__main__':

    q=Queue()

    p_list=[]print('process id',id(q))for i in range(3):

    p= Process(target=f, args=(q,i))

    p_list.append(p)

    p.start()print(q.get())print(q.get())print(q.get())for i inp_list:

    i.join()#output#process id 2284856854176#subprocess id 2607348001872#[42, 0, 'hello']#subprocess id 1712786975824#[42, 2, 'hello']#subprocess id 2254764977120#[42, 1, 'hello']

    Pipe常用来两个进程间进行通信,两个进程分别位于管道的两端

    deff(conn):

    conn.send([42, None, 'hello'])

    conn.close()if __name__ == '__main__':

    parent_conn, child_conn=Pipe()

    p= Process(target=f, args=(child_conn,))

    p.start()print(parent_conn.recv()) #prints "[42, None, 'hello']"

    p.join()

    Pipe方法返回(conn1, conn2)代表一个管道的两个端。Pipe方法有duplex参数,如果duplex参数为True(默认值),那么这个管道是全双工模式,也就是说conn1和conn2均可收发。duplex为False,conn1只负责接受消息,conn2只负责发送消息。

    send和recv方法分别是发送和接受消息的方法。例如,在全双工模式下,可以调用conn1.send发送消息,conn1.recv接收消息。如果没有消息可接收,recv方法会一直阻塞。如果管道已经被关闭,那么recv方法会抛出EOFError。

    #__author: greg#date: 2017/9/21 22:57

    importmultiprocessingimportrandomimporttime,osdefproc_send(pipe,urls):for url inurls:print("Process(%s) send: %s" %(os.getpid(),url))

    pipe.send(url)

    time.sleep(random.random())defproc_recv(pipe):whileTrue:print("Process(%s) rev:%s" %(os.getpid(),pipe.recv()))

    time.sleep(random.random())if __name__=="__main__":

    pipe=multiprocessing.Pipe()

    p1=multiprocessing.Process(target=proc_send,args=(pipe[0],['url_'+str(i)for i in range(10)]))

    p2=multiprocessing.Process(target=proc_recv,args=(pipe[1],))

    p1.start()

    p2.start()

    p1.join()

    p2.terminate()

    Manager()返回的管理器对象控制一个服务器进程,该进程持有Python对象,并允许其他进程使用代理来操纵它们。

    #__author: greg#date: 2017/9/21 23:10

    from multiprocessing importProcess, Managerdeff(d, l,n):

    d[n]= '1'd['2'] = 2d[0.25] =None

    l.append(n)#print(l)

    if __name__ == '__main__':

    with Manager() as manager:

    d=manager.dict()

    l= manager.list(range(5))

    p_list=[]for i in range(10):

    p= Process(target=f, args=(d, l,i))

    p.start()

    p_list.append(p)for res inp_list:

    res.join()print(d)print(l)

    四 进程同步

    当多个进程需要访问共享资源的时候,Lock可以用来避免访问的冲突。

    #__author: greg#date: 2017/9/21 23:25

    from multiprocessing importProcess, Lockdeff(l, i):

    l.acquire()try:print('hello world', i)finally:

    l.release()if __name__ == '__main__':

    lock=Lock()for num in range(10):

    Process(target=f, args=(lock, num)).start()

    五 进程池 Pool类

    Pool可以提供指定数量的进程供用户使用,默认大小是CPU的核数。当有新的请求提交到Pool中时,如果池还没有满,那么就会创建一个新的进程来执行该请求

    但如果池中的进程数已经达到规定的最大值,那么该请求就会等待,直到池中有进程结束,才会创建新的进程来处理它。

    #-*- coding: utf-8 -*-#2017/11/24 20:15

    from multiprocessing importPoolimportos, time, randomdefrun_task(name):print('Task %s (pid = %s) is running...' %(name, os.getpid()))

    time.sleep(random.random()* 3)print('Task %s end.' %name)if __name__=='__main__':print('Current process %s.' %os.getpid())

    p= Pool(processes=3)for i in range(5):

    p.apply_async(run_task, args=(i,))print('Waiting for all subprocesses done...')

    p.close()

    p.join()print('All subprocesses done.')"""Current process 9788.

    Waiting for all subprocesses done...

    Task 0 (pid = 5916) is running...

    Task 1 (pid = 3740) is running...

    Task 2 (pid = 6964) is running...

    Task 2 end.

    Task 3 (pid = 6964) is running...

    Task 1 end.

    Task 4 (pid = 3740) is running...

    Task 0 end.

    Task 3 end.

    Task 4 end.

    All subprocesses done."""

    apply_async(func[, args[, kwds[, callback]]]) 它是非阻塞,apply(func[, args[, kwds]])是阻塞的

    close()    关闭pool,使其不在接受新的任务。

    terminate()    结束工作进程,不在处理未完成的任务。

    join()    主进程阻塞,等待子进程的退出, join方法要在close或terminate之后使用。

    每次最多运行3个进程,当一个任务结束了,新的任务依次添加进来,任务执行使用的进程依然是原来的进程,这一点通过进程的pid可以看出来。

    展开全文
  • 本文修改自:http://linux.chinaunix.net/techdoc/develop/2007/07/20/963167.shtml ... */ ...1 Linux下进程的结构 ... Linux下一个进程在内存里有三部分的数据,就是"代码段"、"堆栈段"和"数据段"。一般的CPU
  • PHP多进程编程实例

    2020-12-18 23:58:37
    想完成任务,又觉得一个进程太慢,那么,试试用多进程来搞吧。这篇文章将会介绍一下PHP多进程的基本需求,如何创建多进程以及基本的信号控制,暂时不会告诉你如何进行进程间通信和信息共享。 1. 准备 在动手之前,请...
  • Python多进程编程

    2017-11-24 20:50:10
    一 多进程编程 Python实现多进程的方式有两种:一种方法是os模块中的fork方法,另一种是使用multiprocessing模块。 前者仅适用于LINUX/UNIX操作系统,对Windows不支持,后者则是跨平台的实现方式。 第一种...
  • 多进程编程

    2018-08-25 13:44:03
    windows中是没有fork函数的,一开始直接在Windows中测试,直接报错 import os import time ret = os.fork() if ret == 0: while True: print("-----1----") time.sleep(1) else: while True: pri....
  • windows及linux下使用python多进程编程

    千次阅读 2017-02-19 18:33:43
    两份资料地址: http://python.jobbole.com/82045/ http://www.liaoxuefeng.com/wiki/001374738125095c955c1e6d8bb493182103fac9270762a000/0013868323401155ceb3db1e2044f80b974b469eb06cb43000
  • thinkphp开发的一个项目,登录成功后又跳转到登录页面,在...受COOKIE送出机制...pcntl系列函数只能在*nix系统上使用,请问windows下能不能做PHP的多进程实现?回复内容:pcntl系列函数只能在*nix系统上使用,请问wind...
  • Windows核心编程多进程概述

    千次阅读 2017-12-11 18:18:52
    一、进程的概念  进程是是一个正在运行的程序的实例(飘~~~),是系统分配资源的单位(线程是执行的单位),包括内存,打开的文件、处理机、外设等,进程由两部分组成:  1、进程的内核对象:即我们通常所讲的...
  • 多进程编程(一)

    2019-04-29 21:36:51
    多进程编程--模块multiprocessing importmultiprocessing #引入多进程编程模块 进程的生命周期: 1、创建进程---multiprocessing.Process()#参数 group=None【windows中可忽略,linux、unix中使用用户分组】,...
  • 主要介绍了深入探究PHP的多进程编程方法,同时介绍了Windows系统下的多线程尝试,是PHP并发实现方面的重要内容,需要的朋友可以参考下
  • Windows多线程编程

    2021-01-22 16:53:52
    熟练掌握Windows下的线程编程,能够让我们编写出更规范线程代码,避免不要的异常。Windows下的线程编程非常复杂,但是了解一些常用的特性,已经能够满足我们普通线程对性能及其他要求。 进程与线程 1. 进程...
  • python多进程编程

    2016-12-12 11:13:41
    最近开始学习PYTHON编程语言,详细参照《python绝技运用Python成为顶级***》。在学习过程第一章节中,编写破解LINUX shadow文件时,想利用多线程加快破解速度。...故还是利用多进程编写了一个简单的脚本文件,代码如...
  • 最近再做一个项目,网络编程的。windows端作为client,linux端做server,进行文件传输。目前的紧张是任意格式的...如何实现多进程的文件传输,并且在windows端建立两个进程可以从sever端将文件从任意地址传送过来呢?
  • 一、数据共享1.进程间的通信应该尽量避免共享数据的方式2.进程间的数据是独立的,可以借助...命令就是一个程序,按回车就会执行(这个只是在windows情况下)tasklist 查看进程tasklist| findstr pycharm #(findstr是进...
  • VC 多进程编程windows下调用记事本、计算器、查看进程。。
  • php有一组进程控制函数,使得php能在*nix系统中实现跟c一样的创建子进程、使用exec函数执行程序、处理信号等功能。引用Process Control support in PHP implements the Unix style of process creation, program ...
  • windows多线程编程

    2016-06-06 20:36:58
    这几天在学windows网络编程。 现在要做成线程模式的,之前对线程也不了解,大概研究以下,下面是研究的内容: 当进程结束后所有线程都终止。线程编程最大的问题在于共享数据的访问控制。 直接用Win32 API进行...
  • PHP多进程:使用PHP的Process Control Functions(PCNTL/线程控制函数)只能用在Unix Like OS,Windows不可用。编译php的时候,需要加上–enable-pcntl,且推荐仅仅在CLI模式运行,不要在WEB服务器环境运行。以下为...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,522
精华内容 1,008
关键字:

windows多进程编程