python3.0的多线程

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了python3.0的多线程，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含7545字，纯文字阅读大概需要11分钟。

内容图文

1.进程

进程：计算机中一个程序在一个数据集上一次动态执行过程，主要包含三部分内容
? 程序：描述进程的功能以及处理流程
? 数据集：功能处理过程中需要的资源数据
? 进程控制：严格控制进程执行过程中的各种状态
一个软件程序要运行，需要将软件依赖的数据加载到内存中，通过 CPU 进行运算并按照程 序定义的逻辑结构进行流程控制，知道数据处理完成后程序退出！ 在程序实际执行过程中，进程只是分配需要的数据资源，是程序的主体，在程序运行时真正 运行的是线程，每个进程至少会有一个线程。

2.线程（Thread）

计算机中程序运行的实际执行者就是线程，线程又称为轻量级进程，是一个 CPU 的执行单 元，每个进程至少会有一个主线程用于执行程序
线程和进程对比如下
? 一个进程可以有多个线程，但是至少有一个主线程
? 一个线程只能属于一个进程
? 一个进程中多个线程，可以共享进程中提供的数据
? CPU 运算分配给线程，CPU 上执行运算的是线程
? 线程是最小的运行单元，进程是最小的资源管理单元

2.1 串行、并行、并发

什么是并发？
所谓并发：表面上是同时执行，并发是相对于顺序执行的概念
并发：在很短的时间之类，多个任务切换执行，在一个时间段~体现出来一种几个任务同时执行的表象，并发，在操作系统中，是指一个时间段中有几个程序都处于已启动运行到运行完毕之间，且这几个程序都是在同一个处理机上运行，担任一个时刻点只有一个程序在处理机上运行。
并行：（以可同时执行的计算指令方式编程）
串行：串行程序中，程序会按照顺序执行每一条指令，在整个程序运行过程中，仅存在一个运行上下文。（即一个调用栈，一个堆）
串行：就是传统意义上的同步、顺序的意思，按照一定的执行步骤顺序执行每个环节

并行：就是传统意义上的异步、同时的意思，同时执行接受到的多个任务

并发：同时接收到多个任务，同时执行多个任务，但是具体到某个时刻~只是在执行一个任 务，只是在很短时间内在多个任务之间切换，模拟形成了多个任务同时执行的现象 而大部分计算机中的应用程序的执行，一般都是并发执行机制的多任务处理机制

2.2多线程编程

PYTHON 本身对于多线程并发机制的支持是比较完善的
在 PYTHON2 中提供了标准模块 thread 和 threading 支持多线程的并发编程 但是随着并发编程的实际使用操作过程，thread 模块过于底层的控制方式对于并发编程的 新手来说挺不是非常友好，要求多线程的程序开发逻辑思维清晰同时又具备大量开发经验的 情况下，可以控制的非常精细。
在PYTHON3 中将 thread 模块进行了规范内置，更名为_thread，友好的提醒如果你不是并发编 程的骨灰级爱好者，请不要轻易尝试使用_thread 进行操作，而是推荐使用操作更加灵活使 用更加简洁的 threading 模块进行并发编程的处理。

2.2.1 PYTHON 中的多线程

官方推荐的_threading 模块的多线程并发编程机制，结合时下流行的面向过程/面向对象的 编程处理模式，主要有两种操作方式
? 函数式的线程创建方式，适合面向过程程序的并发编程实现
? 面向对象的创建方式，适合面向对象程序的并发编程实现
threading 模块属性和方法

2.2.2Thread 类型属性和方法

?多线程售票：相当于多个窗口同时售票（简单）
代码：

"""
desc 多线程并发
version 1.1.0
author lkk
email lkk199404@163.com
"""
import threading, time

ticket = 10


def sale_ticket():
    global ticket
    while ticket > 0:
        print(threading.current_thread().name, '{}号票已经售出'.format(ticket))
        ticket -= 1
        time.sleep(1)


if __name__ == '__main__':

    S1 = threading.Thread(target=sale_ticket, name='窗口1')
    S2 = threading.Thread(target=sale_ticket, name='窗口2')

    S1.start()
    S2.start()
    start = time.clock()
    elapsed = (time.clock() - start)
    print("程序耗时:", elapsed)

程序运行要比单线程程序运行效率大大提高

2.2.3线程状态

join：线程的 join 状态是独占模式，当前线程独占 CPU 运行单元，必须等待当前线程执行完 成或者超时之后，才能运行其他线程 。

"""
desc 线程状态join
version 1.1.0
author lkk
email lkk199404@163.com
"""

# 引入模块
import threading, time

count = 10


def sale_ticket():
    global count
    while count > 0:
        print(threading.current_thread().getName(), "售出一张票：", count)
        count -= 1
        time.sleep(0.5)
    else:
        print(threading.current_thread().getName(), "没有票了")


if __name__ == "__main__":  
    
    # 定义多个线程 ( 窗口 )     
    t1 = threading.Thread(name="窗口 1", target=sale_ticket)     
    t2 = threading.Thread(name="窗口 2", target=sale_ticket)     
    t3 = threading.Thread(name="窗口 3", target=sale_ticket)     
    t4 = threading.Thread(name="窗口 4", target=sale_ticket)    
    t5 = threading.Thread(name="窗口 5", target=sale_ticket) 

# 启动五个窗口同时售票     
    t1.start()     
#  线程 t1 调用 join ，独占模式运行，等待 t1 线程运行结束或者超时，才能继续运行其他线程     
    t1.join()     
    t2.start()     
    t3.start()     
    t4.start()     
    t5.start() 

2.2.4线程管理-锁[Lock/RLock]

多线程程序在运行过程中，由于多个线程访问的是同一部分数据，很容易会造成共享数据访 问冲突的现象，如果一旦出现冲突程序就会出现执行结果不符合期望的结果

修改售票程序，两个窗口同时售票，修改代码如下

"""
desc 多线程并发
version 1.1.0
author lkk
email lkk199404@163.com
"""
import threading, time,os,sys

ticket = 10


def sale_ticket():
    global ticket
    while 1:
        if lock.acquire():
            if ticket > 0:
                print(threading.current_thread().name, '{}号票已经售出'.format(ticket))
                time.sleep(0.2)
                ticket -= 1
            else:
                print(threading.current_thread().name, '票已经售空')
            lock.release()


if __name__ == '__main__':
    lock = threading.Lock()
    S1 = threading.Thread(target=sale_ticket, name='窗口1')
    S2 = threading.Thread(target=sale_ticket, name='窗口2')

    S1.start()
    S2.start()

此时共享数据的修改操作，在多线程的情况下，是需要通过锁定的方式进行独占修改的！ 就如同如厕一样，当多个人[线程]在执行程序，修改数据[如厕]时，每个线程在操作过程中都 需要锁定这一部分数据[厕所]，直到数据处理完成之后解锁，下一个线程才能进行操作

python 中提供了两种线程锁的操作
? 同步锁/互斥锁：Lock
? 可重用锁：RLock

锁的操作主要是获取锁和释放锁两种
? acquire() 获取锁，上锁，锁定
? release() 释放锁，开锁，解锁

2.2.5线程管理-死锁[Dead Lock]

线程锁固然功能强大，可以管理多个线程之间的共享数据问题 但是同时它的强大也带来了比较纠结的问题，需要开发人员对于锁定的数据有一个良好的认 知，否则特别容易造成死锁的现象，比较著名的哲学家吃饭问题就是死锁的典型代表

由于计算机运算速度较快，所以有两种方案可以将问题放大
? 给执行函数添加休眠时间
? 添加线程数量
死锁并不是每次都会出现的，而是程序在执行过程中，根据系统 CPU 时间片的切换机制恰 好遇到了重复上锁的情况，就会死锁
实际项目开发过程中，一定要注意死锁情况的影响 这样的情况可以通过可重用锁 RLock 进行锁定处理！

PYTHON 中的互斥锁，只有两种状态，locked 和 unlocked，如果一旦重复上锁就会死锁 但是可重用锁 RLock，在锁定的基础上提供了一个计数器 counter，可以计算上锁的次数然 后通过 release()解锁时就会重新运算计数器，等待计数器清零时所有锁全都释放了

import threading, time 
def zhexuejia1():    
 	if lock1.acquire():         
 		if lock2.acquire():             
        	print("你给我叉子，我就给你刀子")             
			lock2.release()        
  		lock1.release() 
def zhexuejia2():    
  		if lock2.acquire():         
  			if lock1.acquire():                     
  				print("你给我刀子，我就给你叉子")             
  				lock1.release()         
  			lock2.release() 
 
if __name__ == "__main__": 
    lock1 = threading.Lock()     
    lock2 = threading.Lock() 
    for i in range(1000):         
	    zxj = threading.Thread(name="哲学家 A" + str(i), target=zhexuejia1)         
	    zxj2 = threading.Thread(name="哲学家 B" + str(i), target=zhexuejia2)         
	    zxj.start()         
	    zxj2.start()

内容总结

以上是互联网集市为您收集整理的python3.0的多线程全部内容，希望文章能够帮你解决python3.0的多线程所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端