python进程创建过程和方法

#multiprocess.process模块

#process模块是一个创建进程的模块,借助这个模块,可以完成进程的创建
# Process([group[,target[,name[,args[,kwargs]]]]]) ,由该实例化得到的对象,
# 表示一个子进程的任务(尚未启动)

    #注意(参数介绍):
        #1.需要使用关键字参数的方式来指定参数
        #2.args指定的为传给target函数的位置参数,是一个元组形式,必须有逗号
        #3.group参数为使用,值始终未None
        #4.target表示调用对象,即子进程要执行的任务
        #5.args表示调用对象的字典,kwargs={"name_":"json","age":19}
        #6.name为子进程的名字

    #方法介绍:
        #1.p.start():启动进程,并调用该子进程中的p.run()方法
        #2.p.run():进程启动时运行的方法,正是它去调用target指定的函数,
                # 我们自定义类的类中一定要实现该方法
        #3.p.terminate():强制终止进程p,不会进行任何清理操作
        #4.p.is_alive():如果仍然运行,返回True
        #5.p.join(timeout):主进程等待p终止(注意:主进程处于等的状态,而p
            #是处于运行的状态)timeout是可选的超出时间,需要强调的是p.join只能join
            #主start开启的进程,而不能join住run开启的进程.
    #属性介绍:
        #1.p.daemon:默认值为False,如果设置为True,代表p为后天运行的守护进程
        #2.p.pid:进程的pid   os.getpid() 当前运行进程的pid
        #3.p.exitcode:进程在运行时为None,如果为-N,表示被信号N结束
        #4.p.authkey:进程的身份验证,默认是由os.urandom()随机生成的32位字符的
            #字符串.这个键的用途是为了涉及网络连接的底层间通信提供安全性
            #这类连接只有在具有相同的身份验证键时才能成功.

#process模块创建进程和查看主进程的pid

# from multiprocessing import Process
#
# import time,os
#
# def func(name):
#     print("hello",name)
#     print("我是子进程,我的pid是%s,父进程的pid是%s" %(os.getpid(),os.getppid()))
#
# if __name__ == ‘__main__‘:
#     p = Process(target=func,args=("jack",))  # 元组
#     p.start()   #  开始进程
#     time.sleep(1)
#     print("执行父进程了,父进程的pid是%s,父亲的父进程(pycharm的)pid是%s" %(os.getpid(),os.getppid()))
#结果:
    # hello jack
    # 我是子进程,我的pid是4604,父进程的pid是7728
    # 执行父进程了,父进程的pid是7728,父亲的父进程(pycharm的)pid是4476
    #

#  通过继承创建进程
# from multiprocessing import Process
# class MyProcess(Process):
#     def __init__(self):
#         super(MyProcess, self).__init__()
#
#     def run(self):
#         print("执行子进程")
#

# from multiprocessing import Process
# import os
# class MyPrpcess(Process):
#     def __init__(self,name):
#         super(MyPrpcess, self).__init__()
#         self.name = name
#     def run(self):
#         print(os.getpid())
#         print("%s正在聊天" %self.name)
# if __name__ == ‘__main__‘:
#
#     p1 = MyPrpcess("jack")
#     p2 = MyPrpcess("tom")
#
#     p1.start()  #start会调用run方法
#     p2.start()
#
#     p1.join()
#     p2.join()
#
#     print("主线程")

# if __name__ == ‘__main__‘:
#     p = MyProcess()  #
#       p1.start()# 是指,解释器告诉操作系统,去帮我开启一个进程,   就绪状态
#       p1.run()# 告诉操作系统,现在马上帮我执行这个子进程           执行
#结果: 执行子进程

#  join()方法:

# from multiprocessing import Process
# import time
# def func(name):
#     time.sleep(2)
#     print("hesllo",name)
#     print("执行子进程")
#
# if __name__ == ‘__main__‘:
#     p = Process(target=func,args=("jack",))
#     p.start()
#     p.join()
#     print("执行主进程")

#结果:
# hesllo jack
# 执行子进程
# 执行主进程

# join()的作用:是让主进程等待进程执行完.
        # 现象:主进程执行到这句话,主进程阻塞住,等待子进程子进程执行
#开启一个正常的子进程,父进程会等待子进程结束后,父进程也就是程序才结束
# 如何把父进程和子进程之间的关系变为同步或者异步?
    #父进程执行join,就会变成同步,不执行join,父进程和子进程就是异步关系
    #注意:
        #join 必须放在start()后面

#多进程之间无法共享内存

# from multiprocessing import Process
#
# def func(i):
#     print("我是%s"%i)  #  调用四次都是相互独立的
#     #print(n)   # 无法调用n
# if __name__ == ‘__main__‘:
#     n = 100
#     addr = ["河南","湖北","山东","北京"]
#     for i in addr:
#         p = Process(target=func,args=(i,))
#         p.start()
#结果:
    # 我是河南
    # 我是湖北
    # 我是山东
    # 我是北京

# 多个子进程(子进程的执行顺序不是根据启动顺序决定)

# from multiprocessing import Process
# import random
# import time
# def func(i):
#     print("我是%s"%i)
# if __name__ == ‘__main__‘:
#     lst = []
#     addr = ["河南","湖北","山东","北京"]
#     for i in addr:
#         p = Process(target=func,args=(i,))
#         p.start()
#         lst.append(p)
#         time.sleep(1)
#     [p.join() for p in lst]
#     print("我选%s" %(random.choice(addr)))
#结果:
# 我是河南
# 我是湖北
# 我是山东
# 我是北京
# 我选北京(随机出现)

# 多进程同时运行,join方法1
# from multiprocessing import Process
#
# def func(name):
#     print("hello",name)
#
# if __name__ == ‘__main__‘:
#     lst = []
#     for i in range(5):
#         p = Process(target=func,args=("alex",))
#         p.start()
#         lst.append(p)
#         p.join()
#     print("执行父进程")
#结果:
# hello alex
# hello alex
# hello alex
# hello alex
# hello alex
# 执行父进程

#多进程同时运行,join方法2

# from multiprocessing import Process
# import time
#
# def func(name):
#     print("hello",name)
#     time.sleep(1)
#
# if __name__ == ‘__main__‘:
#     lst = []
#     for i in range(5):
#         p = Process(target=func,args=("jack",))
#         p.start()
#         lst.append(p)
#     [p.join() for p in lst]
#     print("父进程执行")

#结果:
# hello jack
# hello jack
# hello jack
# hello jack
# hello jack
# 父进程执行

  

原文地址:https://www.cnblogs.com/caodneg7/p/9508422.html

时间: 2024-10-18 15:56:53

python进程创建过程和方法的相关文章

Linux进程创建过程

相关学习资料 linux内核设计与实现+原书第3版.pdf(3.3章) 深入linux内核架构(中文版).pdf 深入理解linux内核中文第三版.pdf <独辟蹊径品内核Linux内核源代码导读> http://www.yanyulin.info/pages/2013/11/linux0.html http://blog.csdn.net/ddna/article/details/4958058 http://www.cnblogs.com/coolgestar02/archive/2010

python 进程的一些其他方法

OK通过上面两篇的内容,对进程有了一个初步的认识     进程 就是一个方法,就跟面相对象,函数一样,都是python中的方法,为了能够 让自己程序更有效率.     上两篇就是告诉大家,进程的一个样子,怎样的一个书写格式,   大家只要记住格式是什么,会用就可以了,   进程的那些概念的东西, 大家可以没事上百度,了解一下就可以了. 话不多说,接下来就是   进程 的一些使用方法 import  os                                               

linux内核学习之六 进程创建过程学习

一 关于linux进程概念的补充 关于进程的基本概念这里不多说,把自己的学习所得作一些补充: 1. 在linux内核中,系统最多可以有64个进程同时存在. 2.linux进程包含的关键要素:一段可执行的程序:专用的系统堆栈空间:内核中它的控制块(进程控制块):独立的存储空间. 3. 系统的第一个进程由系统初始化生成. 4. 内核通过一个唯一的进程标识号PID来标识每个进程. 5. 用数据结构task_struct表示一个进程,包括进程的属性和状态.task_struct 结构中的指向前后进程的指

Linux进程创建过程详解

本文首先使用了接口pthread_create创建一个线程,并用strace命令追踪了接口pthread_create创建线程的步骤以及涉及到的系统调用,然后讨论了Linux中线程与进程关系,最后概述了为了实现POSIX线程,Linux内核所做的修改. 一.使用pthread_create创建线程 在Linux下可以使用pthread_create来创建线程,该接口声明如下: #include <pthread.h> int pthread_create(phtread_t *thread,

python 进程创建和共享内容的方法

1.使用Pool来创建进程 from multiprocessing import Pool def f(n): return n*n if __name__=="__main__": p=Pool(5) a=range(10) print(p.map(f,a)) p.map会将a列表中的数据依次循环给f函数.但是当函数需要两个参数时,该方法不适用. 2.使用Process来创建进程 def info(title): print title print 'module name:',

【原创】Python 对象创建过程中元类, __new__, __call__, __init__ 的处理

原始type: type是最原始的元类,其__call__方法是在你使用" t_class = type(classname_string, base_classes_tuple, attributes_dict)" 这种语法来使用时, 在__call__方法内使用又会调用type的__new__和__init__方法来创建classname_string的具体类,并初始化类信息.当type(***)调用完成, classname_string代表的类可以用来创建实例了. 元类调用过程

理解Android进程创建流程(转)

/frameworks/base/core/java/com/android/internal/os/ - ZygoteInit.java - ZygoteConnection.java - RuntimeInit.java - Zygote.java /frameworks/base/core/java/android/os/Process.java /frameworks/base/core/jni/com_android_internal_os_Zygote.cpp /frameworks

Android应用程序进程启动过程的源代码分析

文章转载至CSDN社区罗升阳的安卓之旅,原文地址: http://blog.csdn.net/luoshengyang/article/details/6747696 Android 应用程序框架层创建的应用程序进程具有两个特点,一是进程的入口函数是ActivityThread.main,二是进程天然支持Binder进程间通信 机制:这两个特点都是在进程的初始化过程中实现的,本文将详细分析Android应用程序进程创建过程中是如何实现这两个特点的. Android应用程序框架层创建的应用程序进程

Python Process创建进程的(2种方法)

Python 在 multiprocessing 模块下提供了 Process 来创建新进程.与 Thread 类似的是,使用 Process 创建新进程也有两种方式: 以指定函数作为 target,创建 Process 对象即可创建新进程. 继承 Process 类,并重写它的 run() 方法来创建进程类,程序创建 Process 子类的实例作为进程. Process 类也有如下类似的方法和属性: run():重写该方法可实现进程的执行体. start():该方法用于启动进程. join([