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

    2018-06-13 21:24:24
    进程是一个执行中的程序,每个进程拥有自己的地址空间、内存、数据栈以及其他用于跟踪执行的辅助数据,所以采用进程间通信的方式共享信息,操作系统管理其上所有进程的执行,并为这些进程合理的分配时间。...

    ##

    进程 ##


    进程是一个执行中的程序,每个进程拥有自己的地址空间、内存、数据栈以及其他用于跟踪执行的辅助数据,所以采用进程间通信的方式共享信息,操作系统管理其上所有进程的执行,并为这些进程合理的分配时间。

    创建子进程

    进程之间的父子是相对的

    import time
    import os
    
    
    # os.getpid()获取当前进程的PID号;
    print("主进程%s正在启动....." %(os.getpid()))
    
    # 创建子进程
    # 会返回2个值, 一个为0, 一个为非0;
    # 子进程永远返回的是0, 父进程返回的是子进程的pid;
    # 父进程里面会有很多子进程, 必须记录子进程的pid号;
    pid = os.fork()
    if pid == 0:
        print("这是一个子进程, pid为%d, 父进程的pid为%d" %(os.getpid(), os.getppid()))
    else:
        print("这个是父进程, 创建了一个子进程, 子进程id为%s" %(pid))
    

    创建多线程

    Process用来描述进程对象

    
    import multiprocessing
    import os
    
    
    def work(num):
        print('work-%s' %num)
        #获取当前进程的名称
        print("进程%s 正在运行,pid=%s" %(multiprocessing.current_process().name,
                                   os.getpid()))
    
    
    print("父进程:%s" %(os.getpid()))
    #创建一个列表用来存放子进程对象
    jobs=[]
    
    for i in range(4):
        name="process%s" %(i)
        #实例华一个子进程对象,name表示进程的名字,target表示执行的函数,
        # args为函数需要传入的参数以tuple的形式传入
        p=multiprocessing.Process(name=name,target=work,args=(i,))
        jobs.append(p)
        #启动多进程
        p.start()
    
    for p in jobs:
        #实现所有进程间的同步,等所有子进程结束再执行主进程
        p.join()
    print("主进程结束,pid=%s,ppid=%s" %(os.getpid(),os.getppid()))
    

    运行结果
    父进程:5363
    work-0
    进程process0 正在运行,pid=5364
    work-1
    进程process1 正在运行,pid=5365
    work-2
    进程process2 正在运行,pid=5366
    work-3
    进程process3 正在运行,pid=5367
    主进程结束,pid=5363,ppid=4175

    对守护进程的理解

    Daemon(守护进程)是运行在后台中的一种特殊进程,独立于控制终端并且周期性的执行某种任务或等待处理某些发生事件。常见的守护进程包括:日志进程syslogd、web服务器httpd、邮件服务器和数据库服务器等。

    终止进程

    import multiprocessing
    import os
    import time
    
    # p.terminate()强制终止结束进程, 结束之后通过join方法更新状态;
    def work(num):
    
        print('work-%s' %(num))
        time.sleep(2)
        # 获取当前进程的名称
        print("进程%s正在运行, pid=%s" %(multiprocessing.current_process().name,
                                   os.getpid()))
    
    
    p = multiprocessing.Process(target=work, args=(1,))
    print('Before:', p, p.is_alive())
    p.start()
    print('During:', p , p.is_alive())
    
    # 结束进程的执行;
    # p.terminate()
    print("正在中之进程:", p, p.is_alive())
    p.join()
    print("更新状态后:", p, p.is_alive())
    

    运行结果:
    这里写图片描述

    派生多进程

    class SubProcess(multiprocessing.Process):
        def __init__(self, name, num):
            super(SubProcess, self).__init__()
            self.num = num
    
        def run(self):
            print('work-%s' %(self.num))
            # 获取当前进程的名称
            print("进程%s正在运行, pid=%s" %(multiprocessing.current_process().name,
                                       os.getpid()))
    
    
    
    print("父进程:%s" %(os.getpid()))
    jobs = []
    
    for i in range(10):
        name = "进程%s" %(i)
        # 实例化对象, 默认执行类的构造函数.
        p = SubProcess(name, i)
        jobs.append(p)
        p.start()
    
    
    for  job in jobs:
        job.join()
    
    
    print("主进程结束, pid=%s, ppid=%d" %(os.getpid(), os.getppid()))
    
    进程间的通信
    
    import os
    from multiprocessing import Queue
    from multiprocessing import Process
    from  random import  randint
    
    import time
    
    
    def write(q):
       # 1. python只要是编程, for循环里面不要加运算;
       # list = os.listdir("/etc")   # ['1', '2', '3']
       # for file in os.listdir("/etc"):
       #        print(file)
    
        n = randint(1,5)
        for i in range(n):
            if q.full():
                print("write full")
            else:
                q.put(i)
                time.sleep(3)
                print("队列写入数据%s成功!" %(i))
    
    # 消费者
    def read(q):
        if q.empty():
            print("read none")
        else:
            n = randint(1,5)
            for i in range(n):
                value = q.get()
    
                print("队列读取数据%d成功!" %(value))
    
    
    def main():
        import multiprocessing
    
        q = Queue(5)
        qw = Process(target=write, args=(q,))
        qr = Process(target=read, args=(q,))
    
    
        qw.start()
        qr.start()
        print(multiprocessing.active_children())
    
        qw.join()
        qr.join()
    
        print("进程间通信结束!")
        print("主进程的pid:%s, 父进程的pid为:%s" %(os.getpid(), os.getppid()))
    
    
    
    if __name__ == "__main__":
        main()
    

    创建进程池

    
    
    import os
    from multiprocessing import Manager
    from multiprocessing import Process
    from multiprocessing import Pool
    from  random import  randint
    import time
    
    
    def write(q):
       # 1. python只要是编程, for循环里面不要加运算;
       # list = os.listdir("/etc")   # ['1', '2', '3']
       # for file in os.listdir("/etc"):
       #        print(file)
        n = randint(1,5)
        for i in range(n):
            if q.full():
                print("write full")
            else:
                q.put(i)
                print("队列写入数据%s成功!" %(i))
                time.sleep(1)
    
    # 消费者
    def read(q):
        if q.empty():
            print("read none")
        else:
            n = randint(1,5)
            for i in range(n):
                value = q.get()
                print("队列读取数据%d成功!" %(value))
                time.sleep(1)
    def main():
        import multiprocessing
    
       # 创建队列
        q = Manager().Queue()
        # 创建进程池
        # 默认情况, 进程池的个数为计算机CPU核数-1; Pool(3)
        pool = Pool()
    
    
        pool.apply_async(write, (q,))
        pool.apply_async(read, (q,))
    
        pool.close()
        pool.join()
        print("进程间通信结束!")
        print("主进程的pid:%s, 父进程的pid为:%s" %(os.getpid(), os.getppid()))
    
    
    
    if __name__ == "__main__":
        main()
    
    展开全文
  • Python实现多进程part1

    2020-08-23 11:55:27
    进程part1一、进程介绍1、获取子父进程2、进程的基本使用2、创建带有参数的进程3、进程之间的数据彼此隔离4、多个进程之间的异步并发二、join1、基本语法2、使用自定义类的方法创建进程三、守护进程 一、进程介绍 ...

    一、进程介绍

    进程就是正在运行的程序,它是操作系统中,资源分配的最小单位
    资源分配:分配的是cpu和内存等物理资源,进程号是进程的唯一标识
    获取当前进程–子进程
    异步和同步:

    1、获取子父进程

    os.getpid()
    

    获取当前进程的父进程

    os.getppid()
    

    为解决Windows系统和Linux系统的兼容问题,下面这句话必须加上:
    __name__ == “__main__”

    def func():
    	res1=os.getpid()
    	res2=os.getppid()
    	print(res1,res2)
    #创建子进程,返回进程对象,执行func这个任务
    if __name__ == "__main__":
    	P=Process(target=func)
    	P.start()
    

    运行结果:
    运行结果

    2、进程的基本使用

    引用multiprocessing模块来创建以一个进程:

    from multiprocessing import Process
    import os
    def func():
    	print("子进程为>>{},父进程为>>{}".format(os.getpid(),os.getppid()))
    #为解决系统兼容性问题,必须加下面这句话
    if __name__ == "__main__":
    	#创建子进程,返回进程对象,执行func这个任务
    	p=Process(target=func)
    	#调用子进程
    	p.start()
    

    运行结果:
    运行结果

    2、创建带有参数的进程

    在进程对象的创建处使用args进行传参

    from multiprocessing import Process
    import os
    def func(m,n):
    	print("子进程为>>{},父进程为>>{}".format(m,n))
    #为解决系统兼容性问题,必须加下面这句话
    if __name__ == "__main__":
    	#创建子进程,返回进程对象,执行func这个任务
    	p=Process(target=func,args=(os.getpid(),os.getppid()))
    	#调用子进程
    	p.start()
    

    运行结果:
    运行结果

    3、进程之间的数据彼此隔离

    from multiprocessing  import Process
    import time
    count=0
    def func():
    	global count
    	count += 1
    	print("count:{}".format(count))
    if __name__ == "__main__":
    	p=Process(target=func)
    	p.start()
    	time.sleep(1)
    	print(count)
    

    运行结果:
    运行结果

    如图,子进程对count的操作没有影响到主进程

    4、多个进程之间的异步并发

    多个进程之间是异步并发的程序,因为cpu的调度策略问题,不一定哪个程序先执行,哪个程序后执行
    整体而言,主进程比子进程创建的速度要快,cpu遇到阻塞会立即切换任务,等到阻塞态的任务变成了就绪态,cpu再回来执行
    主程序会默认等到所有子程序执行结束之后,再统一关闭程序,释放资源
    若不等待,有可能在后台存有多个未执行结束的子进程,会变成僵尸进程,不停的占用cpu和内存。

    import time,random,os
    from multiprocessing import Process
    def func(n):
    	time.sleep(random.randrange(3))
    	print("{},子进程:{},父进程:{}".format(n,os.getpid(),os.getppid()))
    if __name__ == "__main__":
    	for i in range(10):
    		p=Process(target=func,args=(i,))
    		p.start()
    	print("主程序结束了")
    	print(os.getpid())
    

    运行结果:
    运行结果

    如图,因为多个进程之间是异步并发的,所以会产生以上结果

    二、join

    等待当前子进程全部执行完毕后,主进程再进行执行

    1、基本语法

    import os,time
    from multiprocessing import Process
    def func1():
    	print("子进程:{}".format(os.getpid()))
    def func2():
    	time.sleep(0.5)
    	print("父进程:{}".format(os.getppid()))
    if __name__ == "__main__":
    	p1=Process(target=func1)
    	p2=Process(target=func2)
    	p1.start()
    	p2.start()
    	#引入join,所有子进程执行完成后执行主进程
    	p1.join()
    	p2.join()
    	print("主进程执行完毕")
    

    运行结果:
    运行结果

    2、使用自定义类的方法创建进程

    自定义进程类的要求:

    • 必须继承Process这个父类
    • 所有进程执行任务的逻辑必须写在run方法里面

    基本写法:

    import os,time
    from multiprocessing import Process
    class MyProcess(Process):
    	def run(self):
    		print("子进程:{},父进程:{}".format(os.getpid(),os.getppid()))
    if __name__ == "__main__":
    	p=MyProcess()
    	p.start()
    	p.join()
    	print("主进程执行结束")
    

    带有参数自定义类的方法:

    import os,time
    from multiprocessing import Process
    class MyProcess(Process):
    	def __init__(self,arg):
    		self.arg=arg
    		super().__init__()
    	def run(self):
    		print(self.arg)
    		print("子进程:{} 主进程:{}".format(os.getpid(),os.getppid()))
    if __name__=="__main__":
    	p=MyProcess(arg="我是传参")
    	p.start()
    	p.join()
    	print("主进程执行结束")
    

    运行结果:
    运行结果

    三、守护进程

    守护进程守护的是主进程,如果主进程中的所有代码执行完毕了,当前这个守护进程会被立刻杀死,立即终止。

    语法:
    进程.daemon = True 设置当前这个进程为守护进程
    必须在start()调用进程之前进行设置

    默认:主进程会等待所有子进程执行结束后,再关闭程序,释放资源

    from multiprocessing import Process
    import time
    def func1():
    	while True:
    		time.sleep(0.5)
    		print("我是守护进程!")
    def func2():
    	time.sleep(3)
    	print("我是子进程!")
    if __name__ == "__main__":
    	p1=Process(target=func1)
    	p2=Process(target=func2)
    	p1.daemon=True
    	p1.start()
    	p2.start()
    	time.sleep(2)
    	print("主进程执行")
    

    运行结果:
    运行结果

    案例:
    监控报活: 利用守护进程特性,监控日志分析服务器是否存活

    from multiprocessing import Process
    import time
    def alive():
    	while True:
    		time.sleep(0.5)
    		print("P1:服务器存活...")
    def func():
    	count=0
    	while True:
    		try:
    			time.sleep(0.5)
    			print("P2:服务器日志分析中...")
    			time.sleep(1)
    			count += 1
    			if count == 3:
    				raise RuntimeError
    		except:
    			break
    if __name__ == "__main__":
    	p1=Process(target=alive)
    	p2=Process(target=func)
    	p1.daemon=True
    	p1.start()
    	p2.start()
    	p2.join()
    	print("服务器出现异常!")
    

    运行结果:
    运行结果

    展开全文
  • Python多进程

    2019-04-09 23:55:25
    # multiprocessing模块的Process类 # from multiprocessing import Process ...# print("子进程" + str(n),os.getpid()) # os.getpid()获取当前进程号 # time.sleep(1) # 不使用进程跑10任务 # s...
    # multiprocessing模块的Process类
    # from multiprocessing import Process
    # import time,os
    # def func(n):
    #     print("子进程" + str(n),os.getpid()) # os.getpid()获取当前进程号
    #     time.sleep(1)
    
    # 不使用多进程跑10个任务
    # startTime = time.time()
    # for n in range(1,11):
    #     func(n)
    # sec = time.time() - startTime
    # print(sec) # 10.00492548942566(耗时/秒)
    
    # 启动子进程跑10个任务
    # if __name__ == "__main__":
    #     p_lst = []
    #     startTime = time.time()
    #     for n in range(1,11):
    #         # 创建一个子进程
    #         p = Process(target=func,args=(n,)) # 函数参数以元组类型传入
    #         p_lst.append(p)
    #     for p in p_lst:p.start() # 启动创建好的进程
    #     for p in p_lst:p.join() # 等待子进程结束
    #     sec = time.time() - startTime
    #     print(sec) # 1.4769437313079834(耗时/秒)
    '''
    输出结果:
    子进程2 8428
    子进程1 16484
    子进程4 7508
    子进程3 10928
    子进程5 16296
    子进程6 12024
    子进程7 13808
    子进程9 8664
    子进程8 10364
    子进程10 2172
    1.5018908977508545
    '''
    
    # 这种方法开启多进程,进程的生命周期(通常常情况下)
    # 主进程随着子进程代码执行时间短,需要等待子进程执行完毕才结束
    # 子进程在自己的代码执行结束就结束
    
    # 多进程开启方法二
    # from multiprocessing import Process
    # import os
    # # 定义一个类,实现一个run方法(只能是run方法)
    # class MyPro(Process):
    #     def run(self):
    #         print("子进程",os.getpid())
    # if __name__ == "__main__":
    #     for n in range(10):
    #         p = MyPro()
    #         p.start()
    '''
    输出结果
    子进程 15332
    子进程 14212
    子进程 13752
    子进程 10416
    子进程 13372
    子进程 1088
    子进程 8924
    子进程 8340
    子进程 10016
    子进程 8428
    '''
    # 传参数版本
    # from multiprocessing import Process
    # import os
    # class MyPro(Process):
    #     # 定义初始化方法
    #     def __init__(self,msg):
    #         # 先执行父类初始化方法
    #         super().__init__()
    #         # 定义派生属性
    #         self.msg = msg
    #     def run(self):
    #         print(self.msg,os.getpid())
    # if __name__ == "__main__":
    #     for n in range(10):
    #         p = MyPro("子进程" + str(n))
    #         p.start()
    
    # 进程间数据是隔离的
    # from multiprocessing import Process
    # import os
    #
    # def func():
    #     global n
    #     n = 0
    #     print("子进程n:",n)
    #
    # if __name__ == "__main__":
    #     n = 100
    #     p = Process(target=func)
    #     p.start()
    #     p.join()
    #     print("主进程n:",n)
    '''
    输出结果:主进程中n的值并没有被改变
    子进程n: 0
    主进程n: 100
    '''
    
    # 守护进程概念--子进程随着主进程代码的执行完毕而结束
    # from multiprocessing import Process
    # import os
    # import time
    # def func():
    #     while True:
    #         print("守护进程运行中")
    #         time.sleep(1)
    # if __name__ == "__main__":
    #     p = Process(target=func)
    #     p.daemon = True # 设置子进程为守护进程
    #     p.start()
    #     print("主进程工作中")
    #     time.sleep(10)
    #     print("主进程工作结束")
    '''
    输出结果:
    主进程工作中
    守护进程运行中
    守护进程运行中
    守护进程运行中
    守护进程运行中
    守护进程运行中
    守护进程运行中
    守护进程运行中
    守护进程运行中
    守护进程运行中
    守护进程运行中
    主进程工作结束
    方法介绍:
    p.is_alive() 判断子进程是否结束
    p.terminate() 终止一个子进程
    p.name # 进程名
    p.pid # 进程ID
    '''
    展开全文
  • python 进程、线程

    2019-04-11 18:14:36
    python中进程、线程相关的知识点总结; mac和windows中略有区别,使用函数并不一样,因为两操作系统的内核不同。 一、进程 三点:1....2.创建个子进程;...获取进程id使用os.getpid即可获取当前进程号 import r...

    python中进程、线程相关的知识点总结;
    mac和windows中略有区别,使用函数并不一样,因为两个操作系统的内核不同。
    一、进程
    三点:1.创建子进程;2.创建多个子进程;3.进程通信
    官网参考文档:doc
    1
    mac系统引入os模块,使用函数fork;win系统引入process模块,使用Process类创建新的进程;
    获取进程id使用os.getpid即可获取当前进程号

    import random
    from multiprocessing import Process
    from multiprocessing import Pool
    import os
    import time
    
    
    def test(arg='name'):
        print('test name: ' + arg + ', pid: ' + str(os.getpid()))
        start = time.time()
        time.sleep(random.random())
        end = time.time()
        print('cost %.2f' %(end - start))
    
    
    def test_process():
        p = Process(target=test, args=('New process!',))
        print('Start other process')
        p.start()
        p.join()  # 可以等待子进程结束后再继续往下运行,通常用于进程间的同步
    
    
    if __name__ == '__main__':
        test_process()
        print('main Process is: ' + str(os.getpid()))
    

    2

    3

    展开全文
  • os.fork()创建父子进程实现任务编程 import os ...else: # 即pid大于0的代码块,可以在此代码块中获取新进程的进程号 print(“原来的进程”) 功能:创建一新的进程 参数:无 返回值: 失败:返回...
  • 文章目录进程进程的概念进程获取进程号获取当前进程号获取进程号带参数传递的进程argskwargs进程之间不共享全局变量主进程会等待所有的子进程结束后再结束守护进程销毁子进程线程线程的概念线程使用线程首先...
  • buildout:一个构建系统,从多个组件来创建,组装和部署应用。 BitBake:针对嵌入式 Linux 的类似 make 的构建工具。 fabricate:对任何语言自动找到依赖关系的构建工具。 PlatformIO:多平台命令行构建工具。 ...
  • Python Cookbook

    2013-07-31 22:33:26
    1.18 一次完成多个替换 36 1.19 检查字符串中的结束标记 39 1.20 使用Unicode来处理国际化文本 40 1.21 在Unicode和普通字符串之间转换 43 1.22 在标准输出中打印Unicode字符 45 1.23 对Unicode数据编码并用于...
  • tts_ali_api(多进程).py

    2019-11-21 17:08:32
    3 安装三阿里云sdk包 pip install aliyun-python-sdk-core==2.13.3 ;pip install alibabacloud-nls-java-sdk==2.0.0 ;pip install aliyun-python-sdk-dyvmsapi==3.0.1 4 设置好txt路径及需要保存mp3路径,就慢慢...
  • 尹成Python27天入门到项目实战

    千人学习 2020-12-05 17:04:22
    多进程实战线程回顾多进程拷贝代码多进程拷贝全局变量获取进程编号subprocess执行LinuxShell信号Linux进程小结__name__进程mutiprocessing创建过程join作用进程不可以用全局变量共享数据进程同步进程pipe发送接收...
  • 多进程+线程打造高效率爬虫

    千次阅读 2017-11-06 00:00:00
    那,那么我们是否可以大胆的设想下,自己搭建一平台,用户可以通过我们的平台来免费查阅需要付费才能查阅或者下载的数据呢? 答案是肯定的哟。 通过2天的准备和分析, 事实证明是可以实现的, ...
  • Python8期 Day33 2019/ 5/33

    2019-05-31 18:59:00
    系统会给每一个进程分配一个进程编号即PID,如同人需要一个身份证来区分。 print(os.getpid()) PPID # 在python中可以使用os模块来获取ppidimport osprint("self",os.getpid()) # 当前进程自己的pidprint(...
  • 需求 由于使用到线程打印,每...因此想到使用字典的方式实现获取进程号与ip对应,进而获取到当前的ip 代码实现 #初始化一全局变量的字典 pid_ip_dictionary = {} #获取当前进程号 pid = threading.currentThre...
  • 函数的返回值 - 没有返回值 / 返回单个值 / 返回多个值 作用域问题 - 局部作用域 / 嵌套作用域 / 全局作用域 / 内置作用域 / 和作用域相关的关键字 用模块管理函数 - 模块的概念 / 用自定义模块管理函数 / 命名冲突...
  • 10 多进程的调用 第35章 01 进程通信 02 进程池 03 协程 04 事件驱动模型 05 IO模型前戏 06 阻塞IO与非阻塞IO 07 select及触发方式 08 select监听连接 09 select与epoll的实现区别 第36章 01 异步IO 02 ...
  • 获取窗口的唯一标识用句柄表示,所以只需要切换句柄,这样就能在多个页面上操作了 HANDLE句柄是Windows操作系统中的一个概念。在Windows程序中,有各种各样的资源(窗口、图标、光标等),系统在创建这些资源时会为...
  • 本着与更 mirai 开发者、用户、支持者共建更好的学习环境为目的,mirai 自 2021 年 3 月 1 日发起官方社区的建设。社区建设可能涉及:学习论坛、插件中心(在建)等。由于社区的运维需要经费,mirai 项目开启 ...
  • 电脑连接上一个手机或多个手机, 确保adb已经添加到环境变量中,执行下面的命令会自动安装本库所需要的设备端程序:uiautomator-server 、atx-agent、openstf/minicap、openstf/minitouch # init 所有的已经连接到...
  • 如果你使用线程、多进程或者并发等在同一时间点请求次的方法,可能会触发b站风控策略,返回的状态码是412,导致无法继续使用爬虫。 当然如果你已经触发风控策略,可以通过设置代理来绕过。设置方法如下: import...
  • 效率问题,没有利用多进程线程以及异步协程技术,速度较慢。 为了解决以上痛点,此项目应用而生,正如其名,我希望OneForAll是一款集百家之长,功能强大的全面快速子域收集终极神器。 目前OneForAll还在开发中...
  • 天线设计MATLAB源码 量化数据下载更新工具 交流QQ群 群号:519597639,加群请说明理由 介绍 在量化策略中,数据是最重要的一环。市场上也已经有很专业的商业数据库。主要分两类: 落地数据库。...多进程
  • memcached完全剖析

    2009-09-28 14:08:40
    首先 memcached 是以守护程序方式运行于一个或多个服务器中,随时接受客户端的连接操作,客户端可以由各种语言编写,目前已知的客户端 API 包括 Perl/PHP/Python/Ruby/Java/C#/C 等等。客户端在与 memcached 服务...
  • rpc_service:RPC服务模块,允许将某一VN Trader进程启动为服务端,作为统一的行情和交易路由通道,允许客户端同时连接,实现多进程分布式系统 data_manager:历史数据管理模块,通过树形目录查看数据库中已有的...
  • rpc_service:RPC服务模块,允许将某一VN Trader进程启动为服务端,作为统一的行情和交易路由通道,允许客户端同时连接,实现多进程分布式系统 data_manager:历史数据管理模块,通过树形目录查看数据库中已有的...
  • Pool进程线程爬取 开始爬取前安装好相应的依赖包,确定抓取目标的地址,选取所需要爬取的信息。首先抓取第一页的内容。我们实现了get_one_page()方法,并给它传入参数。然后将抓取的页面返回,通过main()方法...
  • 关于Ghostcat(幽灵猫CVE-2020-1938漏洞):CNVD-2020-10487(CVE-2020-1938), tomcat ajp 文件读取漏洞poc|Java版本POC|Tomcat-Ajp协议文件读取漏洞|又一个python版本CVE-2020-1938漏洞检测|CVE-2020-1938-漏洞复现...
  • RED HAT LINUX 6大全

    热门讨论 2011-10-21 18:46:06
    6.5.6 获取的信息 103 6.6 小结 104 第7章 SMTP和协议 105 7.1 Internet电子邮件标准的历史简述 105 7.1.1 sendmail介绍 105 7.1.2 邮局协议 105 7.1.3 Internet邮件访问协议 106 7.2 SMTP和sendmail 106 7.2.1 ...
  • 和包已发展成为融合了支付、生活服务、购物等多个场景的开放性平台。用户可通过和包客户端在手机上不仅能使用中国移动提供的移动支付服务,如缴话费、收付款、生活缴费、订单支付等, 主要功能包括: 1、话费缴纳、...
  • 比较麻烦,后面就想到用Perl或Python来写,百度了一番都说Perl语言运行速度快,我在Open-WRT上看了下Perl的包也挺,然后就写了测试脚本,就是压缩同步数据的那段,然后在CentOS上运行测试了下,发现速度比bash快...
  • 合并多个源文件 可变的扩展 配置开发环境 配置管理 辅助类GenericOptionsParser,Tool和ToolRunner 编写单元测试 mapper reducer 本地运行测试数据 在本地作业运行器上运行作业 测试驱动程序 在集群上运行 打包 启动...

空空如也

空空如也

1 2 3
收藏数 42
精华内容 16
关键字:

python获取多个进程号

python 订阅