pid = os.fork()if pid == 0:    print('子进程{}'.format(os.getpid()))    time.sleep(2)    print('子进程over')elif pid>0:    print('主进程{}'.format(os.getpid()))    time.sleep(3)print ("After fork process pid=%s,ppid=%s" % (os.getpid(), os.getppid()))结果：主进程1396子进程1397子进程overAfter fork process pid=1397,ppid=1396After fork process pid=1396,ppid=787

pid = os.fork()if pid < 0:    print("create process failed")elif pid == 0:    print("my PID is",os.getpid()) #子进程PID    print("my parent process-1 PID is",os.getppid()) #父进程PID    sleep(5)    print("my parent process-2 PID is",os.getppid()) #父进程PID    print("this is child process")else:    sleep(1)    print("===========================")    print("the PID is",pid) #父进程中fork()返回值　＝　子进程PID    print("the parent PID is",os.getpid()) #父进程PID    print("this is parent process") 结果：my PID is 4338my parent process-1 PID is 4337===========================the PID is 4338the parent PID is 4337this is parent processmy parent process-2 PID is 2236this is child process

child =subprocess.Popen('cmd',shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)child.wait()child.communicate()print ("Hello")

import subprocessdef test(size):    print ('start')     cmd = 'ddif=/dev/urandom bs=1 count=%d 2>/dev/null' % size    p =subprocess.Popen(args=cmd, shell=True, stdout=subprocess.PIPE,stderr=subprocess.STDOUT, close_fds=True)    # p.communicate()    p.wait()  # 这里超出管道限制，将会卡住子进程    print ('end') # 64KBtest(64 * 1024) # 64KB + 1Btest(64 * 1024 + 1) 使用p.wait时的结果：startendstart 使用p.communicate时的结果：startendstartend

child= subprocess.Popen("ls-l",shell=True, stdout=subprocess.PIPE)  child.poll()　　返回子进程运行状态，主要是两种结果，None代表尚未运行完，而一个返回码则代表已经运行完成并且是成功或失败了child.kill()　　强行终止子进程child.send_signal(...)　　向子进程发送一个信号（具体信号是以什么方式表示不清楚，还待研究）child.terminate()　　终止子进程child.pid　　子进程的pidchild.returncode　　子进程的返回码child.stdin/stdout/stderr　　子进程的标准输入流，标准输出和标准错误输出，都是类文件对象

importmultiprocessingdef task():    print('%s 子进程 is run....'%os.getpid())    time.sleep(3)    print('%s 子进程 is done...'%os.getpid()) if __name__ == '__main__':   p=multiprocessing.Process(target=task)    p.daemon = True  #守护进程    p.start()    p.join()    print('主进程:',os.getpid())结果：1522 子进程 is run....1522 子进程 is done...主进程: 1521注：对于是守护进程的子进程，主进程加join才会等待守护进程执行再结束，主进程不加join时，不会等待守护进程执行，会直接结束。主进程不管加或不加join都会等待非守护子进程结束后再结束，加join后会等待非守护子进程结束后再执行join后面主进程代码。将进程定义为类：import multiprocessingimport timeclassClockProcess(multiprocessing.Process):    def __init__(self,interval):       multiprocessing.Process.__init__(self)       self.interval = interval     def run(self):        n = 5        while n> 0:           print("the time is {0}".format(time.ctime()))           time.sleep(self.interval)           n -= 1 if __name__ == '__main__':    p = ClockProcess(3)    p.start()     注：进程p调用start()时，自动调用run()

from multiprocessing import Poolimport os, time, randomdef worker(msg):    t_start = time.time()    print("%s开始执行,进程号为%d" % (msg,os.getpid()))    random.random()    time.sleep(random.random()*2)    t_stop = time.time()    print(msg,"执行完毕，耗时%0.2f"% (t_stop-t_start))po = Pool(3)  # 定义一个进程池，最大进程数3for i in range(0,10):    # Pool().apply_async(要调用的目标,(传递给目标的参数元祖,))    # 每次循环将会用空闲出来的子进程去调用目标    po.apply_async(worker,(i,))  #异步进程池，同时执行3个进程    # po.apply(worker,(i,))  #同步进程池，必须等待上一个进程执行完毕才会执行下一个进程。print("----start----")po.close()  # 关闭进程池，关闭后po不再接收新的请求po.join()  # 等待po中所有子进程执行完成，必须放在close语句之后print("-----end-----")

def func(name):    #print(name.upper())    returnname.upper() def main():    p =multiprocessing.Pool(3)   print(p.map(func, ['kel','simle']))   print(p.imap(func, ['kel','simle']))    for iin p.imap(func, ['kel','simle']):       print(i)main()结果：['KEL', 'SIMLE']<multiprocessing.pool.IMapIteratorobject at 0x106faaa20>KELSIMLE

示例：def f(conn):   conn.send([42, None, 'hello']) if __name__ =='__main__':parent_conn,child_conn = Pipe()   #parent_conn, child_conn = Pipe(duplex=False)当duplex=False，只能用child_conn发送消息,parent_conn接收消息    p =Process(target = f, args = (parent_conn, ))   p.start()   print(child_conn.recv())   p.terminate()结果：[42, None, 'hello']返回的两个连接对象必须一个发，一个收，不能用同一个对象收发

示例：def worker(s, i):   s.acquire()   print(multiprocessing.current_process().name + " acquire")   time.sleep(1)   print(multiprocessing.current_process().name + " release")   s.release()if __name__ =="__main__":    s =multiprocessing.Semaphore(2)  #最大子进程数两个    for iin range(5):       p = multiprocessing.Process(target=worker, args=(s, i * 2))       p.start()       #p.join()结果：Process-1 acquireProcess-2 acquire Process-1 releaseProcess-3 acquire Process-2 releaseProcess-4 acquire Process-3 releaseProcess-5 acquire Process-4 releaseProcess-5 release注：每次执行的最大子进程数为2.

示例：defwait_for_event(e):   """Wait for the event to be set before doinganything"""   print('wait_for_event: starting')   e.wait()   print('wait_for_event: e.is_set()->' + str(e.is_set()))  defwait_for_event_timeout(e, t):   """Wait t seconds and then timeout"""   print('wait_for_event_timeout: starting')   e.wait(t)   print('wait_for_event_timeout: e.is_set()->' + str(e.is_set()))  if __name__ =='__main__':    e =multiprocessing.Event()    w1 =multiprocessing.Process(name='block', target=wait_for_event, args=(e,))   w1.start()     w2 =multiprocessing.Process(name='non-block',target=wait_for_event_timeout,args=(e,2))   w2.start()    time.sleep(3)    #e.set()print('main: event isset')结果；e.set未执行时： wait_for_event:startingwait_for_event_timeout:startingwait_for_event_timeout:e.is_set()->Falsemain: event is sete.set执行时wait_for_event:startingwait_for_event_timeout:startingwait_for_event_timeout:e.is_set()->Falsemain: event is setwait_for_event: e.is_set()->True

def func(n, a):    n.value= 3.14    a[1] =9999num =multiprocessing.Value('d', 0.0)arr =multiprocessing.Array('i', range(10))#第二个参数如果传入一个数字，此处表示开辟5个空间，且均为整型i，其实就是一个列表[0,0,0,0,0],第二个参数如果传的是列表等，表示就是存入列表中的元素。则表示在共享内存中开辟多大的空间#m = Array('i',5)print(arr[:])p =multiprocessing.Process(target=func, args=(num, arr))p.start()p.join()print(num.value)print(arr[:])结果：[0, 1, 2, 3, 4, 5, 6,7, 8, 9]3.140000104904175[0, 9999, 2, 3, 4, 5,6, 7, 8, 9]在Process进程中，我们修改了Value和Array对象。回到主程序，打印出结果，主程序也看到了两个对象的改变，说明资源确实在两个进程之间共享。with Manager() asmanager:  #做一个别名，此时manager就相当于Manager()       d = manager.dict()  #生成一个可在多个进程之间传递和共享的字典        l = manager.list(range(5))  #生成一个可在多个进程之间传递和共享的列表;通过range(5)给列表中生成5个数据

q.qsize()：返回当前队列包含的消息数量；q.empty()：如果队列为空，返回True，反之False ；q.full()：如果队列满了，返回True,反之False；q.put_nowait(item) #  等效于 put(item,block=False)q.get_nowait()#    等效于 get(item,block=False)q.put(obj [,block=True[, timeout]])

defdaemonize(pid_file=None):   """    创建守护进程    :parampid_file: 保存进程id的文件   :return:   """    # 从父进程fork一个子进程出来    pid =os.fork()    # 子进程的pid一定为0，父进程大于0    if pid:       sys.exit()      # 退出父进程，sys.exit()方法比os._exit()方法会多执行一些刷新缓冲工作     os.chdir('/')   # 子进程默认继承父进程的工作目录，最好是变更到根目录，否则回影响文件系统的卸载   os.umask(0)     # 子进程默认继承父进程的umask（文件权限掩码），重设为0（完全控制），以免影响程序读写文件   os.setsid()     # 让子进程成为新的会话组长和进程组长,由于在调用了fork函数时，子进程全盘拷贝了父进程的会话期、进程组、控制终端等，虽然父进程退出了，但会话期、进程组、控制终端等并没有改变，因此，这还不是真正意义上的独立开来。    _pid =os.fork()     # 注意了，这里是第2次fork，也就是子进程的子进程，我们把它叫为孙子进程    if_pid:       sys.exit()          # 退出子进程     # 此时，孙子进程已经是守护进程了，接下来重定向标准输入、输出、错误的描述符(是重定向而不是关闭, 这样可以避免程序在 print 的时候出错)    #0，1，2 文件描述符代表标准输入设备（比如键盘），标准输出设备（显示器）和标准错误，因为进程1比较特殊，    # 是所有进程的父进程，所以不做输入输出，/dev/null就是空设备，指向它就没有输入输出了。    # 刷新缓冲区先   sys.stdout.flush()   sys.stdin.flush()    # dup2复制文件描述符，重定向到/dev/nul，即丢弃所有输入输出    withopen('/dev/null') as read_null, open('/dev/null', 'w') as write_null:       os.dup2(read_null.fileno(), sys.stdin.fileno()) # 把程序的输入流重定向到上面定义的read_null 文件       os.dup2(write_null.fileno(), sys.stdout.fileno())       os.dup2(write_null.fileno(), sys.stderr.fileno())    ifpid_file:       with open(pid_file, 'w+') as f:           f.write(str(os.getpid()))        atexit.register(os.remove, pid_file)

• import osimport sysimport timeimport atexitimport signalclass Daemon: def__init__(self, pidfile='/*/daemon.pid', stdin='/dev/null', stdout='/dev/null',stderr='/dev/null'): self.stdin = stdin self.stdout = stdout self.stderr = stderr self.pidfile = pidfile defdaemonize(self): if os.path.exists(self.pidfile): raise RuntimeError('Already running.') # First fork (detaches from parent) try: if os.fork() > 0: raise SystemExit(0) except OSError as e: raise RuntimeError('fork #1 faild: {0}({1})n'.format(e.errno, e.strerror)) os.chdir('/') os.setsid() os.umask(0o22) # Second fork (relinquish session leadership) try: if os.fork() > 0: raise SystemExit(0) except OSError as e: raise RuntimeError('fork #2 faild: {0}({1})n'.format(e.errno, e.strerror)) # Flush I/O buffers sys.stdout.flush() sys.stderr.flush() # Replace file descriptors for stdin, stdout, and stderr with open(self.stdin, 'rb', 0) as f: os.dup2(f.fileno(), sys.stdin.fileno()) with open(self.stdout, 'ab', 0) as f: os.dup2(f.fileno(), sys.stdout.fileno()) with open(self.stderr, 'ab', 0) as f: os.dup2(f.fileno(), sys.stderr.fileno()) # Write the PID file with open(self.pidfile, 'w') as f: c = os.getpid() f.write(str(c)) # Arrange to have the PID file removed on exit/signal atexit.register(lambda: os.remove(self.pidfile)) signal.signal(signal.SIGTERM, self.__sigterm_handler) # Ctrl-c #Signal handler for termination (required) @staticmethod def__sigterm_handler(signo, frame): raise SystemExit(1) #Signal handler for termination (required) defstart(self): try: self.daemonize() except RuntimeError as e: print(e) raise SystemExit(1) self.run() defstop(self): try: if os.path.exists(self.pidfile): with open(self.pidfile) as f: os.kill(int(f.read()),signal.SIGTERM) else: print('Not running.') raise SystemExit(1) except OSError as e: if 'No such process' in str(e) andos.path.exists(self.pidfile): os.remove(self.pidfile) defrestart(self): self.stop() self.start() defrun(self):pass

import osimport sysimport timefrom daemon importDaemon classMyTestDaemon(Daemon):    defrun(self):       sys.stdout.write('Daemon started with pid {}n'.format(os.getpid()))       while True:           sys.stdout.write('Daemon Alive!{}n'.format(time.ctime()))           sys.stdout.flush()            time.sleep(5) if __name__ =='__main__':    PIDFILE= '/*/daemon-example.pid'    LOG ='/*/daemon-example.log'    daemon= MyTestDaemon(pidfile=PIDFILE, stdout=LOG, stderr=LOG)    iflen(sys.argv) != 2:       print('Usage: {} [start|stop]'.format(sys.argv[0]))       raise SystemExit(1)     if'start' == sys.argv[1]:       daemon.start()    elif'stop' == sys.argv[1]:       daemon.stop()    elif'restart' == sys.argv[1]:       daemon.restart()    else:       print('Unknown command {!r}'.format(sys.argv[1]))raiseSystemExit(1)