多进程

为每个进程分配一定数量的页面，然后在由进程去给线程分配待抓取页面，抓取到信息之后保存到“博客园.csv”文件中。 第三方模块 aiohttp : 协程模块 beautifulsoup4：解析模块 安装 ： pip install aiohttp pip install beautifulsoup4 多线程 asyncio协程模块，通过这模块来启用任务并限制线程数量。线程多了影响效率，因为线程是通过时间分片来模拟并行，进程是真并行 多进程 multiprocessing 进程模块通过引用Pool类来启用进程池 信息保存 部分代码 import page import asyncio import os from asyncrequest import AsyncHttp from save import db from multiprocessing import Pool # 抓取信息 async def fetch(url, attach=None): reqs = AsyncHttp() text = await reqs.request(url, attach) items = page.FetchList(text) for item in items: arc = page.Article(item) db.writerow({ '作者': arc.author, '头像

进程和线程的区别 进程是对运行时程序的封装，是系统资源调度和分配的基本单位 线程是进程的子任务，cpu调度和分配的基本单位，实现进程内并发。 一个进程可以包含多个线程，线程依赖进程存在，并共享进程内存 什么是线程安全 一个线程的修改被另一个线程的修改覆盖掉。 python中哪些操作是线程安全的 一个操作可以在多线程环境中使用，并且获得正确的结果。 线程安全的操作线程是顺序执行的而不是并发执行的。 一般涉及到写操作需要考虑如何让多个线程安全访问数据。 线程同步的方式 互斥量（锁）： 通过互斥机制防止多个线程同时访问公共资源。 信号量（Semphare）： 控制同一时刻多个线程访问同一个资源的线程数。 ps：python的threading 文档 事件（信号）： 通过通知的方式保持多个线程的同步。 进程间的通信方式 （IPC：Inter-Process Communication 进程间传递信号或者数据） 管道/匿名管道/有名管道（pipe） 信号（Signal）：比如用户使用ctrl+c产生SIGINT程序终止信号 消息队列（Message） 共享内存（share memory） 进程间的信号量（Semaphore） 套接字（socket）：最常用的方式，我们的web应用就是这种方式 多线程的例子 # python实现多线程 import threading lock =

上篇文章 说到，由于Python多线程 multiprocessing 模块中在windows 平台和 Unix 平台系统的底层实现方法不同，所以效率和内存占用会有差别，本文继续记录如何在不同平台实现多线程并行。 Contents 基础的多进程调用函数和模块。 在类的成员函数中调用多进程。 在类的成员函数中调用多进程遇到的一些问题。 如何调用多进程函数 此处以multiprocessing.Pool为例： file1.py def target_fun ( ) : return 1 main function: import multiprocessing from file1 import target_fun if __name__ == '__main__' : pool = multiprocessing . Pool ( N ) # N为pool的数目，如果空缺则pool的数目为cpu的数目 res = pool . starmap ( target_fun , [ [ ] for _ in range ( 10 ) ] ) # pool.starmap 比 pool.map的优点在于，可以输入0~任意个输入参数，而pool.map只有一个参数。后面参数的个数控制了有多少个排队进入pool的子进程 pool . close ( ) # pool关闭，不再接受新的进程

#include <iostream> #include <stdio.h> #include <windows.h> #include<fstream> //ifstream using namespace std; HANDLE Empty, Full, Mutex; //声明3个信号量,mutex为互斥信号量,剩下的为同步信号量,同事同步信号量也起到计数器的作用 句柄类型 int x = 0; int y = 0; ofstream outf; DWORD WINAPI produce(LPVOID param) { int j = 0; do { WaitForSingleObject(Empty, INFINITE);//P（Empty） WaitForSingleObject(Mutex, INFINITE);//P（Mutex）,形成互斥，生产者、消费者，生产者、生产者；只能一个人占用这个资源 //cout << "produce, "; printf("produce,\n"); outf<<"produce,\n"; j++; ReleaseSemaphore(Mutex, 1, NULL);//V（Mutex），取消互斥,允许其他线程生产，占用此互斥资源 ReleaseSemaphore(Full, 1, NULL);//V(Full)，放一个物品到货架

GIL是什么 Python的代码执行由 Python虚拟机（也叫解释器主循环，CPython版本）来控制，Python在设计之初就考虑到在解释器的主循环中，同时只有一个线程在运行。即每个CPU在任意时刻只有一个线程在解释器中运行。对 Python虚拟机访问的控制由全局解释锁GIL控制，正是这个锁来控制同一时刻只有一个线程能够运行。——在单核CPU下的多线程其实都只是并发，不是并行 。 并发与并行区别 并发：两个或多个事件在同一时间间隔发生，或者说交替做不同事件的能力，或者说不同的代码块交替执行。 并行：两个或者多个事件在同一时刻发生，或者说同时做不同事件的能力，或者说不同的代码块同时执行。 并发和并行的意义 并发和并行都可以处理“多任务”，二者的主要区别在于是否是“同时进行”多个的任务。但是涉及到任务分解（有先后依赖耦合度高的任务无法做到并行）、任务运行（可能要考虑互斥、锁、共享等）、结果合并。 Python 下的多线程 在Python多线程下，每个线程的执行方式，如下： 获取GIL 切换到这个线程去执行 运行代码，这里有两种机制： 指定数量的字节码指令（100个） 固定时间15ms线程主动让出控制 把线程设置为睡眠状态 释放GIL 再次重复以上步骤 在Python2中，在解释器解释执行任何 Python 代码时，都需要先获得这把锁才行（同一时间只会有一个获得了 GIL 的线程在跑

并发主干内容回顾 进程: 一个程序运行起来,资源集合. 开启进程的过程: 操作系统开辟一个内存空间, 把代码放进去, 去运行代码(需要cpu). ps:(如果是python的话会把解释器代码也放进去) 特点: 进程的内存空间彼此隔离 主进程要等待所有的子进程结束(原因是:回收僵尸进程) multiprocessing重要用法: join() 等待子进程结束 站在当前进程查看pid 查看父进程的pid : os.getppid() 查看当前进程的pid: os.getpid() 查看子进程的pid: 子进程对象.pid() 守护进程:首先是一个进程, 守护到主进程最后一行代码结束. 进程的互斥锁,一个进程acquire到了在不release的情况下,其他进程无法acquire 比串行好在了是部分代码实现串行 主要用在多个进程修改数据混乱的场景 生产者消费者模型(一种思想) 生产者只负责生产,消费者只负责消费,彼此都达到了自己最大的效率. 生产者-->队列(盆)--->消费者 线程 cpu真正的执行单位是线程 python里使用的线程是操作系统的原生线程. 在传统操作系统中，每个进程有一个地址空间，而且默认就有一个控制线程,cpu真正的执行单位是线程. 线程和进程的关系 进程相当于线程的容器 进程 = 各种资源+线程 产生一个线程的过程: 每开启一个进程就会自带一个线程,

python爬虫之线程池和进程池 一、需求 　　最近准备爬取某电商网站的数据，先不考虑代理、分布式，先说效率问题（当然你要是请求的太快就会被封掉，亲测，400个请求过去，服务器直接拒绝连接，心碎），步入正题。一般情况下小白的我们第一个想到的是for循环，这个可是单线程啊。那我们考虑for循环直接开他个5个线程，问题来了，如果有一个url请求还没有回来，后面的就干等，这么用多线程等于没用，到处贴创可贴。 二、性能考虑 　　确定要用多线程或者多进程了，那我们到底是用多线程还是多进程，有些人对多进程和多线程有一定的偏见，就因为python的GIL锁，下面我们说一下这两个东西的差别。 三、多线程： 　　一般情况下我们启动一个.py文件，就等于启动了一个进程，一个进程里面默认有一个线程工作，我们使用的多线程的意思就是在一个进程里面启用多个线程。但问题来了，为什么要使用多线程呢？我知道启动一个进程的时候需要创建一些内存空间，就相当于一间房子，我们要在这个房子里面干活，你可以想一个人就等于一个线程，你房子里面有10个人的空间跟有20个人的空间，正常情况下是不一样的，因为我们知道线程和线程之间默认是可以通信的（进程之间默认是不可以通信的，不过可以用技术实现，比如说管道）。可以多线程为了保证计算数据的正确性，所以出现了GIL锁，保证同一时间只能有一个线程在计算。GIL锁你可以基本理解为

目录 线程同步锁、死锁、递归锁、信号量、GIL 一、同步锁 二、死锁 三、递归锁（Rlock） 四、信号量（Semphare） 五、GIL（全局解释器锁） io密集型 计算密集型 线程同步锁、死锁、递归锁、信号量、GIL 一、同步锁 所有线程同一时间读写同一个数据，有的线程已经对数据进行修改了，造成有的线程拿到的数据时旧的数据，而不是修改后的数据，造成结果不正确，于是引入了同步锁解决问题， 同步锁的原理是同一时间只能有一个线程读写数据。 锁通常被用来实现对共享资源的同步访问。从threading模块导入一个Lock类，为每一个共享资源创建一个Lock对象，当你需要访问该资源时，调用acquire方法来获取锁对象（如果其他线程已经获得了该锁，则当前线程需等待其被释放），待资源访问完后，再调用release方法释放锁。 下面这个例子就需要用到同步锁： from threading import Thread x = 0 def task(): global x for i in range(20000): x=x+1 # t1 的 x刚拿到0 保存状态 就被切了 # t2 的 x拿到0 进行+1 1 # t1 又获得运行了 x = 0 +1 1 # 思考:一共加了几次1? 加了两次1 真实运算出来的数字本来应该+2 实际只+1 # 这就产生了数据安全问题. if __name__ ==

一、线程锁 1.多个线程抢占资源的情况： 锁通常被用来实现对共享资源的同步访问。为每一个共享资源创建一个Lock对象，当你需要访问该资源时，调用acquire方法来获取锁对象（如果其它线程已经获得了该锁，则当前线程需等待其被释放），待资源访问完后，再调用release方法释放锁： 案例一： from threading import Thread,Lock import time K = Lock() def func(): global n K.acquire() # 加锁 team = n time.sleep(0.1) # 分析：第一个线程刚拿到team = n = 100,就遇到阻塞，马上切换到下一个线程，下一个线程还是跟上一个线程一样的情况， # 由于线程切换速度很快，一直拿到的team都是99，除非你的线程数量足够大。 # 解决方法： 给处理数据部分进行加锁处理。 n = team-1 K.release() # 释放锁 if __name__ == '__main__': n = 100 l = [] for i in range(100): t = Thread(target=func) l.append(t) t.start() for t in l: t.join() print(n) 案例二： from threading import Thread,Lock

目录 第十五章、Python多线程之信号量和GIL 1. 信号量(Semaphore) 2. GIL 说明： 第十五章、Python多线程之信号量和GIL 1. 信号量(Semaphore) 信号量用来控制线程并发数的，Semaphore管理一个内置的计数 器，每当调用acquire()时-1，调用release()时+1。计数器不能小于0，当计数器为 0时，acquire()将阻塞线程至同步锁定状态，直到其他线程调用release()。其实就是控制最多几个线程可以操作同享资源。 import threading import time semaphore = threading.Semaphore(5) def func(): if semaphore.acquire(): print (threading.currentThread().getName() + '获取共享资源') time.sleep(2) semaphore.release() for i in range(10) t1 = threading.Thread(target=func) t1.start() -------------------------------------------------- Thread-1获取共享资源 Thread-2获取共享资源 Thread-3获取共享资源 Thread