python开发【第4篇】【进程、线程、协程】

一、进程与线程概述：

  1. 进程，是并发执行的程序在执行过程中分配和管理资源的基本单位，每一个进程都有一个自己的地址空 间。
  2. 线程，是进程的一部分，一个没有线程的进程可以被看作是单线程的。线程有时又被称为轻权进程或轻量级进程，也是 CPU 调度的一个基本单位。
  3. 联系：
    • 进程拥有一个完整的虚拟地址空间，不依赖于线程而独立存在；
    • 线程是进程的一部分，没有自己的地址空间，与进程内的其他线程一起共享分配给该进程的所有资源。

　　4.区别：

    • 每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。线程不能够立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。 
    • 进程就是一个应用程序在处理机上的一次执行过程，它是一个动态的概念，而线程是进程中的一部分，进程包含多个线程在运行。

　　5. 线程的执行特性：

    • 线程只有 3 个基本状态：就绪，执行，阻塞。
    • 线程存在 5 种基本操作来切换线程的状态：派生，阻塞，激活，调度，结束。

　　6. 进程通信：

    • 单机系统中进程通信有 4 种形式：主从式，会话式，消息或邮箱机制，共享存储区方式。
    • 主从式典型例子：终端控制进程和终端进程。
    • 会话式典型例子：用户进程与磁盘管理进程之间的通信。

 　　7.多进程和多线程：

　　　　为何需要多进程（或者多线程），为何需要并发？

　　　　多线程/进程，就像一个快餐点的服务员，既要在前台接待客户点 餐，又要接电话送外卖，没有分身术肯定会忙得你焦头烂额的。

　　　　多进程/线程技术是这么一种技术，让你可以像孙悟空一样分身，灵魂出窍，乐哉乐哉地轻松应付一切状 况。

　　　　并发技术，就是可以让你在同一时间同时执行多条任务的技术。你的代码将不仅仅是从上到下，从左到右这样规规矩矩的一条线执行。

　　　　你可以一条线在main函数里跟你的客户交流，另一条线，你早就把你外卖送到了其他客户的手里。

 二、Python-线程

　　1.Threading模块　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

用于提供线程相关的操作，线程是应用程序中工作的最小单元。

“““
创建了10个“前台”线程，然后控制器就交给了CPU，CPU根据指定算法进行调度，分片执行指令
”””

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import threading
import time
  
def show(arg):
    time.sleep(1)
    print 'thread'+str(arg)
  
for i in range(10):
    t = threading.Thread(target=show, args=(i,))
    t.start()
  
print 'main thread stop'

更多Threading模块方法：

  • start            　　    线程准备就绪，等待CPU调度
  • setName                为线程设置名称
  • getName                获取线程名称
  • setDaemon            设置为后台线程或前台线程（默认）
                       　　           如果是后台线程，主线程执行过程中，后台线程也在进行，主线程执行完毕后，后台线程不论成功与否，均停止
                                         如果是前台线程，主线程执行过程中，前台线程也在进行，主线程执行完毕后，等待前台线程也执行完成后，程序停止
  • join                        逐个执行每个线程，执行完毕后继续往下执行，该方法使得多线程变得无意义
  • run                        线程被cpu调度后自动执行线程对象的run方法
线程自定义类：
import threading
import time
 
class MyThread(threading.Thread):
    def __init__(self,num):
        threading.Thread.__init__(self)
        self.num = num
 
    def run(self):#定义每个线程要运行的函数
 
        print("running on number:%s" %self.num)
 
        time.sleep(3)
 
if __name__ == '__main__':
 
    t1 = MyThread(1)
    t2 = MyThread(2)
    t1.start()
    t2.start()

　　2.线程锁（Lock、RLock）　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

由于线程之间是进行随机调度，并且每个线程可能只执行n条执行之后，当多个线程同时修改同一条数据时可能会出现脏数据，所以，出现了线程锁 - 同一时刻允许一个线程执行操作。

  • Lock对象【acquire、release方法】若1个线程连续2次进行acquire操作，那么忧郁第1次acquire后未release，第2次acquire将挂起线程，会导致Lock对象一直不会release，导致线程死
  • RLock对象【acquire、release方法】允许1个线程多次对其进行acquire操作（原因：内部通过1个counter变量维护线程acquire的次数），且每1次acquire操作必须有1个release操作与之对应，在所有的release操作完成后，别的线程才能申请该RLock对象 
    #!/usr/bin/env python
#coding:utf-8
   
import threading
import time
   
gl_num = 0
   
lock = threading.RLock()
   
def Func():
    lock.acquire()
    global gl_num
    gl_num +=1
    time.sleep(1)
    print gl_num
    lock.release()
       
for i in range(10):
    t = threading.Thread(target=Func)
    t.start()

　　3.互斥锁【信号量:Semaphore】　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

互斥锁 同时只允许一个线程更改数据，而Semaphore是同时允许一定数量的线程更改数据 ，比如厕所有3个坑，那最多只允许3个人上厕所，后面的人只能等里面有人出来了才能再进去。

import threading,time
 
def run(n):
    semaphore.acquire()
    time.sleep(1)
    print("run the thread: %s" %n)
    semaphore.release()
 
if __name__ == '__main__':
 
    num= 0
    semaphore  = threading.BoundedSemaphore(5) #最多允许5个线程同时运行
    for i in range(20):
        t = threading.Thread(target=run,args=(i,))
        t.start()

　　4.事件【event】　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

python线程的事件用于主线程控制其他线程的执行，事件主要提供了三个方法 set、wait、clear。

事件处理的机制：全局定义了一个“Flag”，如果“Flag”值为 False，那么当程序执行 event.wait 方法时就会阻塞，

如果“Flag”值为True，那么event.wait 方法时便不再阻塞。

  • clear　　将“Flag”设置为False
  • set          将“Flag”设置为True
#!/usr/bin/env python
# -*- coding:utf-8 -*-
 
import threading
 
def do(event):
    print 'start'
    event.wait()
    print 'execute'
  
event_obj = threading.Event()
for i in range(10):
    t = threading.Thread(target=do, args=(event_obj,))
    t.start()
 
event_obj.clear()
inp = raw_input('input:')
if inp == 'true':
    event_obj.set()

　　5.条件（Condition）　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

使得线程等待，只有满足某条件时，才释放n个线程

import threading
 
def run(n):
    con.acquire()
    con.wait()
    print("run the thread: %s" %n)
    con.release()
 
if __name__ == '__main__':
 
    con = threading.Condition()
    for i in range(10):
        t = threading.Thread(target=run, args=(i,))
        t.start()
 
    while True:
        inp = input('>>>')
        if inp == 'q':
            break
        con.acquire()
        con.notify(int(inp))
        con.release()

　　6.定时器【Timer】　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

定时器，指定n秒后执行某操作

from threading import Timer

def hello():
    print("hello, world")
 
t = Timer(1, hello)
t.start()  # after 1 seconds, "hello, world" will be printed

三、Python-进程

　　1.进程创建　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

from multiprocessing import Process
import threading
import time
  
def foo(i):
    print 'say hi',i
  
for i in range(10):
    p = Process(target=foo,args=(i,))
    p.start()

　　2.进程数据共享　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

 进程各自持有一份数据，默认无法共享数据

  • 进程间默认无法数据共享
#!/usr/bin/env python
#coding:utf-8
 
from multiprocessing import Process
from multiprocessing import Manager
 
import time
 
li = []
 
def foo(i):
    li.append(i)
    print 'say hi',li
  
for i in range(10):
    p = Process(target=foo,args=(i,))
    p.start()
     
print 'ending',li
  • 进程间数据共享实现方法
#方法一，Array
from multiprocessing import Process,Array
temp = Array('i', [11,22,33,44])
 
def Foo(i):
    temp[i] = 100+i
    for item in temp:
        print i,'----->',item
 
for i in range(2):
    p = Process(target=Foo,args=(i,))
    p.start()
 
#方法二：manage.dict()共享数据
from multiprocessing import Process,Manager
 
manage = Manager()
dic = manage.dict()
 
def Foo(i):
    dic[i] = 100+i
    print dic.values()
 
for i in range(2):
    p = Process(target=Foo,args=(i,))
    p.start()
    p.join()
#!/usr/bin/env python
# -*- coding:utf-8 -*-

from multiprocessing import Process, Array, RLock

def Foo(lock,temp,i):
    """
    将第0个数加100
    """
    lock.acquire()
    temp[0] = 100+i
    for item in temp:
        print i,'----->',item
    lock.release()

lock = RLock()
temp = Array('i', [11, 22, 33, 44])

for i in range(20):
    p = Process(target=Foo,args=(lock,temp,i,))
    p.start()
进程锁实例：

相关文章：

  • 2021-05-18
  • 2022-12-23
  • 2021-12-16
  • 2021-06-02
  • 2022-12-23
  • 2022-02-13
猜你喜欢
  • 2022-12-23
  • 2022-12-23
  • 2021-10-14
  • 2021-11-14
  • 2022-12-23
  • 2021-12-04
相关资源
相似解决方案
热门标签
Java Python linux javascript Mysql C# Docker 算法 前端 SpringBoot Redis Vue spring 设计模式 .net core .net kubernetes c++ 数据库 数据结构 大数据 js 机器学习 微服务 Android Go 程序员 面试 JVM ASP.net core 云原生 人工智能 后端 PHP git CSS golang k8s Nginx Django mybatis 深度学习 多线程 React 架构 devops 爬虫 云计算 Spring Boot LeetCode