标签：tar   print   __name__   port   sync   daemon   分享图片   多少   targe   

一、昨日内容回顾

　　　1. 概念和理论

　　　　　　进程是计算机资源分配最小单位

　　　　　　进程三状态、同步、异步、阻塞、非阻塞

　　　2. 进程的创建

　　　　　　实例化、自建类run，start，join，terminate，daemon等

　　　3.进程的同步控制

　　　　　　 Lock：互斥锁

　　　　　　Semaphore：锁+计数器

　　　　　　Event：事件

　　　4.进程间的通信

　　　　　　队列Queue：put、get、empty、full、put_nowait、get_nowait 管道+锁

　　　　　　　　进程之间的数据安全--进程安全

　　　　　　　　可以是任意数据类型

　　　　　　管道Pipe：

　　　　　　　　有两端，双向通信

　　　　　　　　需要关闭掉不用的所有端口，才会在recv处报错

　　　　　　　　进程不安全

            5.数据共享 Manager：dict,list

　　　　　　 # 进程都在同一台计算机上使用

　　　　　　# 数据在进程之间不安全

　　　　　　目前常用的进程之间的数据共享：消息中间件

　　　　　　　　#memcache

　　　　　　　　#rabbitmq

　　　　　　　　#redis

            6.进程池Pool

　　　　　　#什么情况下用进程池：

　　　　　　　　# 高cpu型的代码需要用进程池

　　　　　　　　#进程池cpu个数+1

　　　　　　# Pool池

　　　　　　　　apply同步

　　　　　　　　apply_async 异步提交

　　　　　　　　　　#get 获取返回值

　　　　　　　　　　#close

　　　　　　　　　　#join

　　　　　　　　map

　　　　　　　　　　# apply_async的简化版，它内部实现了close和join方法

　　　　　　　　　　#但是没有get方法，无法接受返回值

　　　　　　　　回调函数：apply_async(callback=???)

　　　　　　　　　　# 回调函数实在主进程中执行的

              7，信号量和进程池的区别，信号量的用处

　　　　　　　　#在同一时刻只会有n个进程在执行某段代码

　　　　　　　　#不同：

　　　　　　　　　　#信号量是有多少任务开启多少进程，信号量仍然给操作系统带来了很多负担。

　　　　　　　　　　# 池中进程的数量是固定的，只是分别借用池中的进程来执行任务而已

                          信号量的用处（同一target函数中，高IO部分用多进程，高CPU部分用信号量计算，这样节省进程切换等开销）：

二、线程

　　　　1. 线程的概念和特点

              为什么有进程还要开启线程：

　　　　线程是计算机中能被cpu调度的最小单位：

               多线程的特点：并发的、轻量级、数据不隔离

　　　　 多进程的特点：并发的、操作笨重、数据隔离

               2.线程的开启

import json
import time,os
from threading import Thread


def func():
    for i in range(10):
        time.sleep(0.5)
        print(‘Thread:‘, i,os.getpid())


if __name__ == ‘__main__‘:
    t = Thread(target=func)
    t.start()
    time.sleep(1)
    print(‘in main 1‘,os.getpid())
    time.sleep(1)
    print(‘in main 2‘,os.getpid())

主线程和子线程在同一进程

　　　　3.效率测试

from multiprocessing import Process
from threading import Thread
import time


def func(num):
    print(num**num)


if __name__ == ‘__main__‘:
    p_lst = []
    start = time.time()
    for i in range(50):
        p = Process(target=func, args=(i,))
        p.start()
        p_lst.append(p)
    for i in p_lst:
        i.join()
    print(‘======‘, time.time()-start)

    t_lst = []
    start = time.time()
    for i in range(50):
        t = Thread(target=func, args=(i,))
        t.start()
        t_lst.append(p)
    for i in t_lst:
        i.join()
    print(‘********‘, time.time()-start)

对于高计算任务，多线程高出多进程几个数量级

　　　　4.数据隔离性测试

from threading import Thread

n =100

def func():
    global n
    n -= 1


t = Thread(target=func)
t.start()
t.join()
print(n)

数据隔离，线程共享进程资源

　　　　5.子进程和主进程

from threading import Thread,currentThread
import time


def func():
    time.sleep(1)
    print(‘子进程‘, currentThread())


t = Thread(target=func)
t.start()
print(‘主进程‘, currentThread())   # 主线程结束意味着主进程结束，主线程会等着子线程结束才结束

主线程结束意味着主进程结束，主线程会等着子线程结束才结束

 　　    6.全局解释器锁GIL

python全栈开发day34-线程Thread

标签：tar   print   __name__   port   sync   daemon   分享图片   多少   targe   

原文地址：https://www.cnblogs.com/wuchenggong/p/9183532.html