spider ---- 进程&线程+++多进程&多线程

1案例演示:

进程-面向过程

import time
from multiprocessing import Process


def sing():
    for x in range(1, 6):
        print('你在唱女儿情')
        time.sleep(1)


def dance():
    for x in range(1, 6):
        print('你在跳小苹果')
        time.sleep(1)


def main():
    # 创建两个进程,分别执行一个函数
    p_dance = Process(target=dance)
    p_sing = Process(target=sing)

    # 启动进程,两个子进程
    p_dance.start()
    p_sing.start()
    # 主进程需要等待子进程结束在结束
    p_dance.join()
    p_sing.join()

    print('主进程,子进程全部运行结束')


if __name__ == '__main__':
    main()

进程-面向对象:

import time
from multiprocessing import Process


class SingProcess(Process):
    def __init__(self, name):
        super().__init__()
        self.name = name

    # 重写run方法,函数名字为run不能更改
    def run(self):
        for x in range(1, 6):
            print('%s在读红楼梦' % self.name)
            time.sleep(1)


class DanceProcess(Process):
    def run(self):
        for x in range(1, 6):
            print('你在跳钢管舞')
            time.sleep(1)


def main():
    name = '郭襄'
    p_sing = SingProcess(name)
    p_dance = DanceProcess()

    p_sing.start()
    p_dance.start()

    p_sing.join()
    p_dance.join()

    print("主进程,子进程运行结束")


if __name__ == '__main__':
    main()

进程池演示:

import os
import random
import time
from multiprocessing import Pool


def demo(name):
    print('%s---任务正在执行,进程id号---%s' % (name, os.getpid()))
    lt = [1, 2, 3]
    time.sleep(random.choice(lt))


def main():
    # 创建进程池 对象
    pol = Pool(3)  # 最多创建3个进程
    # 任务名字列表
    lt = ['杨过', '阳顶天', '独孤求败', '雕兄', '虚竹', '段正淳', '段誉', '令狐冲', '周伯通', '金轮法王']
    # 循环给池子添加任务
    for name in lt:
        pol.apply_async(demo, args=(name,))
    # 关闭池子不再添加
    pol.close()
    # 主进程等待进程池里面所有的进程结束之后在结束
    pol.join()
    print('主进程,子进程全部运行结束')


if __name__ == '__main__':
    main()

2、多任务
   多个任务同时执行
   生活中：唱歌跳舞、开车手脚并用
   计算机中：浏览器、sublime、vnc、录屏，多个任务都在同时执行
   代码中：写一个段代码，一个函数可以称之为一个任务。
   要想实现多任务同时执行：多进程、多线程
   四个关键字
   同步执行完任务a才能执行任务b
   异步执行任务a的同时也执行任务b
   并行任务a和任务b真的在同时运行真异步
   并发任务a和任务b在一段时间在同时运行伪异步
3、多进程（process）
   怎么理解进程？
   在电脑中，启动一个软件，系统就会分配一个进程
   在代码中，写好的代码没有运行之前称之为程序，运行的时候就是一个进程
   以前写的代码都只有一个主进程，需要通过主进程来创建其他的子进程
   进程创建
   （1）面向过程
       p = Process(target=xxx, args=(xxx,))
       target: 进程启动之后要执行的函数
       args: 主进程给子进程传递的参数
       p.start() 启动进程
       p.join() 让主进程等待
       os.getpid() 获取当前进程id号
       os.getppid() 获取父进程id号
   （2）面向对象
       class MyProcess(Process):
           def run(self):
               pass
       进程启动执行run方法，如果需要传参，需要重写构造方法，在构造方法中要记得手动调用父类的构造方法
   进程之间是否共享局部变量
       不共享
   进程之间是否共享全局变量
       不共享
       进程之间不共享任何数据
   进程池
       请问：进程是不是创建的越多越好？
       小例子：比如给一个文件夹，文件夹里面有100个文件
       copy(src, dst)
       不是绝对的。要开辟多少个进程拷贝呢？
       开辟5个进程，实现100个文件的拷贝
       最多开辟5个进程，这个东西我们称之为进程池
4、多线程（thread）
   如何理解线程？
   比如在qq里面，可以同时语音和视频，在word里面，可以同时打字、拼写检查
   这些同时执行的就可以理解为线程
   多任务-多进程、多线程
   进程和线程的区别
   （1）线程属于进程，一个线程只能属于一个进程，一个进程里面可以有多个线程。
   （2）系统分配资源的基本单位是进程。
   （3）系统调度资源的基本单位是线程。
   画图理解
   以前的程序只有一个进程，主进程，在这个进程里面只有一个线程，主线程
   创建线程
   （1）面向过程创建
       t = threading.Thread(target=xxx, name=xxx, args=(xxx,))
       target: 线程启动要执行的函数
       name: 给线程起名字 threading.current_thread().name
       args: 主线程给子线程传递参数
       t.start()
       t.join()
   （2）面向对象创建
   线程之间是否共享局部变量
       不共享
   线程之间是否共享全局变量
       共享
   线程安全、线程同步
       a += 1
       多个线程往同一个文件中写内容
       锁，独自使用，开锁，
       在操作之前加锁，然后操作，操作完毕之后，释放锁
       上锁的时候是抢的。
       牺牲了性能。
       from threading import Lock
       # 创建一把锁, 多个线程使用一把锁
       lock = Lock()
       # 上锁
       lock.acquire()
       # 释放锁
       lock.release()
5、队列
   生活中：买火车票，队列特点：先进先出
   栈：先进后出
   程序中： from queue import Queue
   q = Queue(5)
   q.put(xxx) 添加元素
   q.get() 获取元素
   q.full() 判断队列是否满
   q.empty() 判断队列是否为空
   q.qsize() 得到队列中元素的个数
6、多线程爬虫
   线程和队列，生产者消费者模型
   while 1:
       生产数据
       消费数据

   生产数据线程
       数据队列
   消费数据线程

   到爬虫中
   for page in range(1, 11):
       拼接url，发送请求，得到响应
           数据队列
       解析响应，保存数据

spider ---- 进程&线程+++多进程&多线程

猜你喜欢