8.6 python 日学 多任务 进程及线程

1.进程
运行起来的程序成为进程，不运行时称为程序。程序和进程的关系是：程序只有一个，但是进程可以有多个。
创建多进程
from multiprocessing import Process
import time

def sing():

for i in range(10):

print(‘我在唱第{}句歌词’.format(i+1))

time.sleep(1)

def dance():

for i in range(10):

print(‘我在跳第{}段舞蹈’.format(i+1))

time.sleep(1)

if name == ‘main’:

t1=Process(target=sing)

t2=Process(target=dance)

t1.start()

t2.start()

2.进程的状态
在程序运行的过程中，由于被操作系统的调度算法控制，程序会进入几个状态：就绪，运行和阻塞
3.进程之间的通讯
进程之间的通讯可以使用Queue队列

from multiprocessing import Queue

q=Queue(4)

q.put(‘baozi’)

q.put(‘xiangjiao’)

q.put(‘xigua’)

print(‘here’)

q.put(‘zhuzhouhzi’)

print(‘eat’)

while q.qsize()>0:

print(q.get())

from multiprocessing import Process,Queue

import time

def producer(q):

for i in range(10):

bz=‘baozi:%d’%(i+1)

print(‘produce’+bz)

q.put(bz)

time.sleep(1)

def consumer(q):

for i in range(10):

bz=q.get()

print(‘consumer’+bz)

if name == ‘main’:

q=Queue(3)

p1=Process(target=producer,args=(q,))

p2=Process(target=consumer,args=(q,))

p1.start()

p2.start()

4.进程池

from multiprocessing import Pool

import time

def hanshu(name):

for i in range(5):

print(name,i)

time.sleep(1)

if name == ‘main’:

p=Pool(3)

a=‘abcde’

for x in a:

# p.apply(hanshu,(x,))

p.apply_async(hanshu,(x,))

p.close()

p.join()

join 主进程等待所有子进程执行完毕，必须在close之后
close等待所有进程结束才关闭进程池
5.线程
进程是资源拥有者，创建、撤销与切换存在较大的内存开销，因此需要引入轻型进程，即线程。
进程是资源分配的最小单位，线程是cpu调度的最小单位（程序真正执行的时候调用的是线程），每一个进程中至少有一个线程。进程里面的所有线程共享进程里面的所有资源。
6.使用threading模块创建线程

from threading import Thread

import time

count=0

def hanshu1():

global count

time.sleep(1)

for i in range(10):

count+=1

print(‘hanhsu1’,count)

def hanshu2():

global count

time.sleep(1)

for i in range(10):

count+=1

print(‘hanhsu2’,count)

if name == ‘main’:

t1=Thread(target=hanshu1)

t2=Thread(target=hanshu2)

t1.start()

t1.join()

t2.start()

t2.join()

传递参数，通过线程关键字args=()进行传递参数

from threading import Thread

import time

def get(num):

for i in range(num):

print(i)

time.sleep(1)

if name == ‘main’:

t1=Thread(target=get,args=(5,))

# t1.setDaemon(True)将当前线程设置为守护线程，当主线程结束后，不管子线程有没有执行完毕，都会结束

t1.start()

print(‘over’)

setDeamon()方法
将当前线设置成守护线程来守护主线程
当主线程结束后，守护线程也结束，不管有没有执行完毕
注意，需要在子线程开启的时候设置成守护线程，否则无效

7.线程的一些实例方法，了解
getName（）获取线程名称
setName（）设置线程名称
isAlive()判断线程存活状态
8.threading提供的方法
threading.currentThread():返回当前线程变量
threading.enumerate()：返回一个包含正在运行的线程list，不包括启动前和终止后的线程
threading.active_count()返回正在运行的线程数量

from threading import Thread

import time

import threading

def sing():

for i in range(10):

print(‘sing%d’%(i+1),threading.current_thread())

time.sleep(1)

def dance():

for i in range(10):

print(‘dance%d’%(i+1),threading.current_thread())

time.sleep(1)

if name == ‘main’:

t1=Thread(target=sing,name=‘ldh’)

t2=Thread(target=dance,name=‘zhm’)

t1.start()

t2.start()

print(threading.enumerate())

print(threading.active_count(),len(threading.enumerate()))

t1.join()

t2.join()

print(‘over’)

9.以继承的方式开启线程

import threading,time

from threading import Thread

class T(Thread):

def init(self,name):

super().init()

self.name=name

def run(self):

for i in range(10):

print(self.name,‘dance%d’%(i+1))

time.sleep(1)

class S(Thread):

def init(self,name):

super().init()

self.name=name

def run(self):

for i in range(10):

print(self.name,‘sing%d’%(i+1))

time.sleep(1)

if name == ‘main’:

t=T(‘zs’)

s=S(‘ls’)

t.start()

s.start()

10.线程之间共享全局变量

import threading

g_num=0

def hanshu1():

global g_num

g_num+=5

def hanshu2():

print(g_num)

if name == ‘main’:

t1=threading.Thread(target=hanshu1)

t2=threading.Thread(target=hanshu2)

t1.start()

t2.start()

11.共享全局变量的问题
多线程开发的时候共享全局变量会带来资源竞争效果，也就是数据不安全# import threading

g_num=0

def hanshu1():

global g_num

for i in range(10000000):

g_num+=1

print(g_num)

def hanshu2():

global g_num

for i in range(10000000):

g_num+=1

print(g_num)

if name == ‘main’:

t1=threading.Thread(target=hanshu1)

t2=threading.Thread(target=hanshu2)

t1.start()

t2.start()

多次运行会发现，全局变量没有按照想象中的那样运行，并给出了一个错误结果