python---多任务编程

一、多任务编程

1、什么叫“多任务”？

 就是操作系统可以同时运行多个任务。打个比方,你一边在用浏览器上网,一边在听MP3,一边在用Word赶作业,这就是多任务,至少同时有3个任务正在运行。还有很多任务悄悄地在后台同时运行着,只是桌面上没有显示而已。

2、单核CPU如何实现“多任务”？

 操作系统轮流让各个任务交替执行,每个任务执行0.01秒,这样反复执行下去。表面上看,每个任务交替执行,但CPU的执行速度实在是太快了,感觉就像所有任务都在同时执行一样。

 三个执行实例A、B、C在单个CPU上交替执行，在逻辑上表现为三个执行实例并行执行，但物理上依然是串行执行。

3、多核CPU如何实现“多任务”？

 真正的并行执行多任务只能在多核CPU上实现，但是，由于任务数量远远多余CPU的核心数量，所以，操作系统也会自动把很多任务轮流调度到每个核心上去执行。

并行：可以理解为一个核心上多个任务交替执行；
并发：多个任务在不同的核心上同时执行。

二、多进程编程

1、进程的创建

1、进程VS程序
编写完毕的代码，在没有运行的时候，称之为程序
正在运行的代码，就成为了进程
注意： 进程，除了包含代码以外，还有需要运行的环境等等，所以进程和程序是有区别的

2、进程的五状态模型

create：创建，ready：就绪，running：运行，terminated：结束（退出），waiting：阻塞

3、创建子进程
Python的os模块封装了常见的系统调用，其中就包括fork，在Windows在没有fork函数，可以在python程序中轻松创建子进程：

子进程会复制父进程的所有东西。

关于fork()函数：
 • 执行到os.fork()时,操作系统会创建一个新的进程复制父进程的所有信息到子进程中
 • 普通的函数调用,调用一次,返回一次,但是fork()调用一次,返回两次
 • 父进程和子进程都会从fork()函数中得到一个返回值,子进程返回是0,而父进程中返回
子进程的 id号

创建子进程：

import os
import time

# print("当前的进程pid:%s" %(os.getpid()))
# # 在pycharm编写代码，程序的父进程就是Pycharm；
# print("当前进程的父进程为：%s " %(os.getppid()))

#定义一个全局变量money
money = 100
print("开始创建子进程......")

pid = os.fork()
if pid == 0:
    money = 200
    print("这是子进程返回的0,子进程的pid为%d,父进程为%d,money=%d"%(os.getpid(),os.getppid(),money))
else:
    print("这是父进程返回的,返回值为子进程的pid,为%d" %(pid))
    print(money)

# time.sleep(16)

开始创建子进程......
这是父进程返回的,返回值为子进程的pid,为4909
100
这是子进程返回的0,子进程的pid为4909,父进程为4902,money=200

注意： 多进程中，每个进程中所有数据（包括全局变量）都各有拥有一份，互不影响

2、多进程编程

Windows没有fork调用,由于Python是跨平台的,multiprocessing模块就是跨平台的多版本的多进程模块。multiprocessing模块提供了一个Process类来代表一个进程对象。

Process的参数：
Process([group [, target [, name [, args [, kwargs]]]]])
target:表示这个进程实例所调用对象;
args:表示调用对象的位置参数元组;
kwargs:表示调用对象的关键字参数字典;
name:为当前进程实例的别名;
group:大多数情况下用不到;

Process类常用方法：
is_alive():判断进程实例是否还在执行;
join([timeout]): 是否等待进程实例执行结束,或等待多少秒;
start(): 启动进程实例(创建子进程);
run(): 如果没有给定target参数,对这个对象调用start()方法时,就将执行对象中的run()方法;
terminate():不管任务是否完成,立即终止;

Process类常用方法：
name:当前进程实例别名,默认Process-N,N为从1开始计数;
pid:当前进程实例的PID值;

多进程编程方法1—实例化对象

import time
from multiprocessing import Process

def task1():
    print("正在听音乐")
    time.sleep(1)

def task2():
    print("正在编程......")
    time.sleep(1)

def no_multi():
    task1()
    task2()

def use_multi():
    p1 = Process(target=task1())
    p2 = Process(target=task2())
    p1.start()
    p2.start()
    #p.join()阻塞当前主进程,当p1.start()之后,p1就提示主进程,需要等待p1进程执行结束后才能向下执行,此时主进程为等待状态,
    p1.join()
    p2.join()

if __name__ == '__main__':
    #主进程
    start_time = time.time()
    no_multi()      #2.0017189979553223
    # use_multi()     #2.02367901802063
    end_time = time.time()
    print(end_time-start_time)

多进程编程方法2—创建子类（继承的方式）

from multiprocessing import Process
import time

class MyProcess(Process):
    """创建自己的进程,父类是Process"""
    def __init__(self,music_name):
        """传递参数music_name"""
        super(MyProcess, self).__init__()
        self.music_name = music_name
    def run(self):
        """重写run方法,内容是你要执行的任务"""
        print("听音乐%s" %(self.music_name))
        time.sleep(1)

if __name__ == '__main__':
    for i in range(10):
        p = MyProcess("音乐%d" %(i))
        p.start()

3、进程池

为什么需要进程池？
• 当被操作对象数目不大时,可以直接利用multiprocessing中的Process动态成生多个进程,十几个还好,但如果是上百个,上千个目标,手动的去限制进程数量却又太过繁琐,此时可以发挥进程池的功效。
• Pool可以提供指定数量的进程供用户调用,当有新的请求提交到pool中时,如果池还没有满,那么就会创建一个新的进程用来执行该请求;但如果池中的进程数已经达到规定最大值,那么该请求就会等待,直到池中有进程结束,才会创建新的进程来它。
图解：
多进程判断素数和进程池：

def is_prime(num):
    """判断素数"""
    if num == 1:
        return False

    for i in range(2, num):
        if num % i == 0:
            return False
    else:
        return True


def task(num):
    if is_prime(num):
        print("%d是素数" % (num))


# 判断1000-1200之间的所有素数
from multiprocessing import Process


def use_multi():
    ps = []
    # 不要开启太多的进程,创建进程会消耗时间和空间(内存)
    for num in range(1, 10000):
        # 实例化进程对象
        p = Process(target=task, args=(num,))
        # 开启进程
        p.start()
        # 存储所有的子进程对象
        ps.append(p)

    # 阻塞子进程,等待所有的子进程执行结束,再执行主进程
    [p.join() for p in ps]


def no_multi():
    for num in range(1, 10000):
        task(num)


def use_pool():
    """使用进程池"""
    from multiprocessing import Pool
    from multiprocessing import cpu_count
    #创建进程池对象
    p = Pool(cpu_count())
    p.map(task, list(range(1, 10000)))  #必须传入可迭代的参数,pool.map()会自动创建和提交任务，自带 start() 和 join()   以异步的方式提交任务
    p.close()  # 关闭进程池
    p.join()  # 阻塞,等待所有的子进程执行结束,再执行主进程


if __name__ == '__main__':
    import time
    start_time = time.time()
    # no_multi()              #0.41280388832092285
    # use_multi()                 
    use_pool()          #0.3200874328613281
    end_time = time.time()
    print(end_time - start_time)

进程池Pool实现方法2：

from multiprocessing import Pool


def job(id):
    print("start %d..." % (id))
    print("end %d..." % (id))


# 创建进程池对象
pool = Pool(processes=4)

# 给进程池分配任务
for i in range(10):
    pool.apply_async(job, args=(i + 1,))  #apply_async不用等待当前进程执行结束，随时根据系统调度来进行进程切换。
pool.close()
#等待所有的子进程执行结束,关闭进程池对象
pool.join()
print("所有的任务执行结束......")

apply方法是阻塞的，意思是等待当前子进程执行完毕后，再执行下一个进程。
apply_async是异步非阻塞的，不用等待当前进程执行结束，随时根据系统调度来进行进程切换。

4、进程间通信

进程通信的目的

进程间通信方法

消息队列
通过multiprocessing模块的Queue实现多进程之间的数据传递，Queue本身是一个消息队列程序。

Queue的常用方法：

Queue.qsize()	返回当前队列包含的消息数量
Queue.empty()	如果队列为空，返回True,反之False
Queue.full()	如果队列满了，返回True，反之False
Queue.get([block[, timeout]])	获取队列中的一条消息,然后将其从列队中移除,block默认值为True)
Queue.get_nowait()	相当Queue.get(False)，队列为空时直接退出，不等待
Queue.put(item,[block[, timeout]])	将item消息写入队列,block默认值 为True，队列满时，一直等待队列中出现新的空位时插入
Queue.put_nowait(item)	相当Queue.put(item, False)，队列满时，直接退出

消息队列：

import time
from multiprocessing import Process
import multiprocessing

class Producer(Process):
    def __init__(self,queue):
        super(Producer, self).__init__()
        self.queue = queue

    def run(self):
        #将需要通信的数据写入队列中
        for i in range(10):
            self.queue.put(i)
            time.sleep(0.1)
            print("传递消息,内容为%s" %(i))
class Consumer(Process):
    def __init__(self,queue):
        super(Consumer, self).__init__()
        self.queue = queue
    def run(self):
        while True:
            time.sleep(0.1)
            recvData = self.queue.get()
            print("接收到另一个进程传递的数据：%s" %(recvData))

if __name__ == '__main__':
    q = multiprocessing.Queue()
    p1 = Producer(q)
    c1 = Consumer(q)

    p1.start()
    c1.start()
    p1.join()
    c1.join()

三、多线程编程

1、多线程编程

 线程（英文：thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程的实际运作单位。同一进程中的线程共享同一存储单元。

2、什么是线程？

每个进程至少有一个线程，即进程本身。进程可以启动多个线程。操作系统像并行“进程”一样执行这些线程。

线程的理解：

import threading

if __name__ == '__main__':
    # 一个进程里面一定有一个线程， 叫主线程.
    print("当前线程个数:", threading.active_count())
    print("当前线程信息:", threading.current_thread())

3、线程和进程各自有什么区别和优劣呢？

 进程是资源分配的最小单位，线程是程序执行的最小单位
 进程有自己独立的地址空间。线程是共享进程中的数据的，使用相同的地址空间。
 进程之间的通信需要以通信的方式（IPC）进行。线程之间的通信更方便，同一进程下的线程共享全局变量、静态变量等数据，难点：处理好同步与互斥。

4、线程分类

有两种不同的线程：
 内核线程
 用户空间线程或用户线程
内核线程是操作系统的一部分,而内核中没有实现用户空间线程。

5、多线程编程

 方法一、python的thread模块是比较底层的模块，python的threading模块是对thread做了一些包装的，可以更加方便的被使用
分析：
• 多线程程序的执行顺序是不确定的
• 当执行到sleep语句时,线程将被阻塞(Blocked),等到sleep结束后,线程进入就绪(Runnable)状态,等待调度。而线程调度将自行选择一个线程执行。
• 代码中只能保证每个线程都运行完整个run函数,但是线程的启动顺序、 run函数中每次循环的执行顺序都不能确定。

多线程实现的方法1—通过实例化对象的方式实现多线程

"""
通过实例化对象的方式实现多线程
"""
import time
import threading
def task():
    """当前要执行的任务"""
    print("听音乐........")
    time.sleep(1)

if __name__ == '__main__':
    start_time = time.time()
    threads = []
    for  count in range(5):
        t = threading.Thread(target=task)
        # 让线程开始执行任务
        t.start()
        threads.append(t)

    # 等待所有的子线程执行结束， 再执行主线程;
    [thread.join() for thread in threads]
    end_time = time.time()
    print(end_time-start_time)

多线程实现的方法2—创建子类

from threading import  Thread
class GetHostAliveThread(Thread):
    """
    创建子线程， 执行的任务：判断指定的IP是否存活
    """
    def __init__(self, ip):
        super(GetHostAliveThread, self).__init__()
        self.ip = ip
    def run(self):
        # # 重写run方法: 判断指定的IP是否存活
        # """
        # >>> # os.system()  返回值如果为0， 代表命令正确执行，没有报错; 如果不为0， 执行报错;
        # ...
        # >>> os.system('ping -c1 -w1 172.25.254.49 &> /dev/null')
        # 0
        # >>> os.system('ping -c1 -w1 172.25.254.1 &> /dev/null')
        # 256
        # """
        import os
        # 需要执行的shell命令
        cmd = 'ping -c1 -w1 %s &> /dev/null' %(self.ip)
        result = os.system(cmd)
        #  返回值如果为0， 代表命令正确执行，没有报错; 如果不为0， 执行报错;
        if result != 0:
            print("%s主机没有ping通" %(self.ip))
if __name__ == '__main__':
    print("打印172.25.254.0网段没有使用的IP地址".center(50, '*'))
    for i in range(1, 255):
        ip = '172.25.254.' + str(i)
        thread = GetHostAliveThread(ip)
        thread.start()

6、线程的几种状态

项目案例：IP地址归属地批量查询任务

import requests
import json
from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
from threading import Thread


def task(ip):
    """获取指定IP的所在城市和国家并存储到数据库中"""
    # 获取网址的返回内容
    url = 'http://ip-api.com/json/%s' % (ip)
    try:
        response = requests.get(url)
    except Exception as e:
        print("网页获取错误:", e)
    else:
        # 默认返回的是字符串
        """
        {"as":"AS174 Cogent Communications","city":"Beijing","country":"China","countryCode":"CN","isp":"China Unicom Shandong Province network","lat":39.9042,"lon":116.407,"org":"NanJing XinFeng Information Technologies, Inc.","query":"114.114.114.114","region":"BJ","regionName":"Beijing","status":"success","timezone":"Asia/Shanghai","zip":""}
        """
        #获取相应页面的文本信息，默认是字符串
        contentPage = response.text
        # 将页面的json字符串转换成便于处理的字典;
        data_dict = json.loads(contentPage)
        # 获取对应的城市和国家
        city = data_dict.get('city', 'null')  # None
        country = data_dict.get('country', 'null')

        print(ip, city, country)
        # 存储到数据库表中ips
        ipObj = IP(ip=ip, city=city, country=country)
        session.add(ipObj)
        session.commit()


if __name__ == '__main__':
    engine = create_engine("mysql+pymysql://root:westos@172.25.34.250/pymysql",
                           encoding='utf8',
                           # echo=True
                           )
    # 创建缓存对象
    Session = sessionmaker(bind=engine)
    session = Session()

    # 声明基类
    Base = declarative_base()


    class IP(Base):
        __tablename__ = 'ips'
        id = Column(Integer, primary_key=True, autoincrement=True)
        ip = Column(String(20), nullable=False)
        city = Column(String(30))
        country = Column(String(30))

        def __repr__(self):
            return self.ip


    # 创建数据表
    Base.metadata.create_all(engine)

    # 1.1.1.1 -- 1.1.1.10
    threads = []
    for item in range(10):
        ip = '1.1.1.' + str(item + 1)  # 1.1.1.1 -1.1.1.10
        # task(ip)
        # 多线程执行任务
        thread = Thread(target=task, args=(ip,))
        # 启动线程并执行任务
        thread.start()
        # 存储创建的所有线程对象;
        threads.append(thread)

    [thread.join() for thread in threads]
    print("任务执行结束.........")
    print(session.query(IP).all())

7、共享全局变量

优点: 在一个进程内的所有线程共享全局变量,能够在不使用其他方式的前提 下完成多线
程之间的数据共享(这点要比多进程要好)
缺点: 线程是对全局变量随意遂改可能造成多线程之间对全局变量的混乱(即线程非安全)

如何解决共享全局变量带来的线程不安全问题？
GIL(global interpreter lock): python解释器中任意时刻都只有一个线程在执行;Python代码的执行由Python 虚拟机(也叫解释器主循环,CPython版本)来控制,Python 在设计之初就考虑到要在解释器的主循环中,同时只有一个线程在执行,即在任意时刻,只有一个线程在解释器中运行。对Python 虚拟机的访问由全局解释器锁(GIL)来控制,正是这个锁能保证同一时刻只有一个线程在运行。

8、线程同步

**线程同步:**即当有一个线程在对内存进行操作时,其他线程都不可以对这个内存地址进行操作,直到该线程完成操作, 其他线程才能对该内存地址进行操作.
同步就是协同步调,按预定的先后次序进行运行。如:你说完,我再说。
"同"字从字面上容易理解为一起动作 其实不是,"同"字应是指协同、协助、互相配合。

如何实现线程同步？—线程锁

共享数据：

money = 0


def add():
    for i in range(1000000):
        global money
        lock.acquire()
        money += 1
        lock.release()
def reduce():
    for i in range(1000000):
        global money
        lock.acquire()
        money -= 1
        lock.release()
if __name__ == '__main__':
          from threading import  Thread, Lock
          # 创建线程锁
          lock = Lock()
          t1 = Thread(target=add)
          t2 = Thread(target=reduce)
          t1.start()
          t2.start()
          t1.join()
          t2.join()
          print(money)

注意：当没有线程锁时当数据量过多的时候可能会发生意想不到的结果。

9、死锁

在线程间共享多个资源的时候,如果两个线程分别占有一部分资源并且同时 等待对方的资源,就会造成死锁。

import time
import threading


class Account(object):
    def __init__(self, id, money, lock):
        self.id = id
        self.money = money
        self.lock = lock

    def reduce(self, money):
        self.money -= money

    def add(self, money):
        self.money += money


def transfer(_from, to, money):
    if _from.lock.acquire():
        _from.reduce(money)

        time.sleep(1)
        if to.lock.acquire():
            to.add(money)
            to.lock.release()
        _from.lock.release()


if __name__ == '__main__':
    a = Account('a', 1000, threading.Lock())  # 900
    b = Account('b', 1000, threading.Lock())  # 1100

    t1 = threading.Thread(target=transfer, args=(a, b, 200))
    t2 = threading.Thread(target=transfer, args=(b, a, 100))
    t1.start()
    t2.start()
    print(a.money)
    print(b.money)

四、协程

协程,又称微线程,纤程。英文名Coroutine。协程看上去也是子程序,但执行过程中,在子程序内部可中断,然后转而执行别的子程序,在适当的时候再返回来接着执行。

协程优势
• 执行效率极高,因为子程序切换(函数)不是线程切换,由程序自身控制,
• 没有切换线程的开销。所以与多线程相比,线程的数量越多,协程性能的优势越明显。
• 不需要多线程的锁机制,因为只有一个线程,也不存在同时写变量冲突,在控制共享资源时也不需要加锁,因此执行效率高很多。

gevent实现协程

基本思想:
当一个greenlet遇到IO操作时,比如访问网络,就自动切换到其他的greenlet,等到IO操作完成,再在适当的时候切换回来继续执行。由于IO操作非常耗时,经常使程序处于等待状态,有了gevent为我们自动切换协程,就保证总有greenlet在运行,而不是等待IO。

import gevent

import requests
import json


from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
from threading import Thread

from gevent import monkey
# 打补丁
monkey.patch_all()


def task(ip):
    """获取指定IP的所在城市和国家并存储到数据库中"""
    # 获取网址的返回内容
    url = 'http://ip-api.com/json/%s' % (ip)
    try:
        response = requests.get(url)
    except Exception as e:
        print("网页获取错误:", e)
    else:
        # 默认返回的是字符串
        """
        {"as":"AS174 Cogent Communications","city":"Beijing","country":"China","countryCode":"CN","isp":"China Unicom Shandong Province network","lat":39.9042,"lon":116.407,"org":"NanJing XinFeng Information Technologies, Inc.","query":"114.114.114.114","region":"BJ","regionName":"Beijing","status":"success","timezone":"Asia/Shanghai","zip":""}
        """
        contentPage = response.text
        # 将页面的json字符串转换成便于处理的字典;
        data_dict = json.loads(contentPage)
        # 获取对应的城市和国家
        city = data_dict.get('city', 'null')  # None
        country = data_dict.get('country', 'null')

        print(ip, city, country)
        # 存储到数据库表中ips
        ipObj = IP(ip=ip, city=city, country=country)
        session.add(ipObj)
        session.commit()


if __name__ == '__main__':
    engine = create_engine("mysql+pymysql://root:westos@172.25.35.250/pymysql",
                           encoding='utf8',
                           # echo=True
                           )
    # 创建缓存对象
    Session = sessionmaker(bind=engine)
    session = Session()

    # 声明基类
    Base = declarative_base()


    class IP(Base):
        __tablename__ = 'ips'
        id = Column(Integer, primary_key=True, autoincrement=True)
        ip = Column(String(20), nullable=False)
        city = Column(String(30))
        country = Column(String(30))

        def __repr__(self):
            return self.ip


    # 创建数据表
    Base.metadata.create_all(engine)

    # 使用协程
    gevents = [gevent.spawn(task, '1.1.1.' + str(ip + 1)) for ip in range(10)]
    gevent.joinall(gevents)
    print("执行结束....")