《Python核心编程》18.多线程编程(三)

18.6使用threading模块

#!/usr/bin/env python
# -*- coding:utf-8 -*-

"""从Thread类中派生出一个子例,创建一个这个子类的实例"""

import threading
from time import sleep, ctime

loops = (4, 2)

class MyThread(threading.Thread):
    """
    1.子类化Thread类
    2.要先调用基类的构造器,进行显式覆盖
    3.重新定义run()函数
    """
    def __init__(self, func, args, name=‘‘):
        super(MyThread, self).__init__()
        self.name = name
        self.func = func
        self.args = args

    def run(self):
        self.func(*self.args)

def loop(nloop, nsec):
    print ‘start loop‘, nloop, ‘at:‘, ctime()
    sleep(nsec)
    print ‘loop‘, nloop, ‘done at:‘, ctime()

def main():
    print ‘starting at:‘, ctime()
    threads = []
    nloops = range(len(loops))

    for i in nloops:
        t = MyThread(loop, (i, loops[i]), loop.__name__)  # 创建子类的实例
        threads.append(t)

    for i in nloops:
        threads[i].start()

    for i in nloops:
        threads[i].join()

    print ‘all DONE at:‘, ctime()

if __name__ == ‘__main__‘:
    main()

18.7MyThread子类化

#!/usr/bin/env python
# -*- coding:utf-8 -*-

"""
1.单独化子类,让Thread的子类更加通用。
2.加上getResult()函数译返回函数的运行结果。

"""
import threading
from time import ctime

class MyThread(threading.Thread):
    def __init__(self, func, args, name=‘‘):
        threading.Thread.__init__(self)
        self.name = name
        self.func = func
        self.args = args

    def getResult(self):
        return self.res

    def run(self):
        print ‘starting‘, self.name, ‘at:‘, ctime()
        self.res = apply(self.func, self.args)
        print self.name, ‘finished at:‘, ctime()

18.8斐波那契、阶乘、累加和

#!/usr/bin/env python
# -*- coding:utf-8 -*-

from myThread import MyThread
from time import ctime, sleep

def fib(x):
    """求斐波那契数列之和"""
    sleep(0.005)
    if x < 2:
        return 1
    return fib(x-2) + fib(x-1)

def fac(x):
    """求阶乘"""
    sleep(0.1)
    if x < 2:
        return 1
    return x * fac(x-1)

def sum_(x):
    """自然数累加和"""
    sleep(0.1)
    if x < 2:
        return 1
    return x + sum_(x-1)

funcs = [fib, fac, sum_]  # 将三个函数放到列表中
n = 12

def main():
    nfuncs = range(len(funcs))  # nfuncs = range(3)

    print ‘*** SINGLE THREAD‘  # 单线程计算三个函数
    for i in nfuncs:
        print ‘staring‘, funcs[i].__name__, ‘at:‘, ctime()  # 打印出函数名称,开始运行时间
        print funcs[i](n)  # 打印计算结果
        print funcs[i].__name__, ‘finished at:‘, ctime()  # 打印出函数名称,结束运行时间

    print ‘\n*** MULTIPLE THREADS‘  # 多线程计算三个函数
    threads = []
    for i in nfuncs:
        t = MyThread(funcs[i], (n,), funcs[i].__name__)  # 实例化三个MyThread对象
        threads.append(t)  # 将三个对象放到列表中

    for i in nfuncs:
        threads[i].start()  # 启动三个线程

    for i in nfuncs:
        threads[i].join()  # join()会等到线程结束或超时,即允许主线程等待线程结束
        print threads[i].getResult()  # 调用对象的getResult()方法

    print ‘all DONE‘

if __name__ == ‘__main__‘:  # 独立运行脚本,即在此脚本在直接运行时,才会调用main()函数
    main()

18.9生产者-消费者问题

#!/usr/bin/env python
# -*- coding: utf8 -*-

from random import randint  # randint随机进行生产和消耗
from time import sleep
from Queue import Queue
from myThread import MyThread

def writeQ(queue):
    print ‘producing object for Q...‘, queue.put(‘xxx‘, 1)  # 把xxx对象放进队列中,并等待队列中有空间为止
    print "size now", queue.qsize()  # 返回队列大小

def readQ(queue):
    val = queue.get(1)  # 从队列中取出一个对象(消耗)
    print ‘consumed object form Q... size now‘, queue.qsize()  # 返回队列大小

def writer(queue, loops):
    """一次往队列中放进一个对象,等待一会,然后再做给定次数的相同的事"""
    for i in range(loops):
        writeQ(queue)  # 调用writeQ,放进一个对象
        sleep(randint(1, 3))  # 随机睡眠1~3秒

def reader(queue, loops):
    """一次从队列中取出一个对象,等待一会,然后做给定次数的相同的事"""
    for i in range(loops):
        readQ(queue)
        sleep(randint(2, 5))  # 睡眠时间比 write 中的长,以使 reader 在取数据的时候能够拿到数据

funcs = [writer, reader]
nfuncs = range(len(funcs))

def main():
    nloops = randint(2, 5)
    q = Queue(32)  # 创建一个大小为32的对象,和 q 绑定

    threads = []
    for i in nfuncs:
        t = MyThread(funcs[i], (q, nloops), funcs[i].__name__)  # 实例化 writer, reader 这两个对象
        threads.append(t)  # 放入空列表中

    for i in nfuncs:
        threads[i].start()  # 启动线程

    for i in nfuncs:
        threads[i].join()  # join()会等到线程结束或超时,即允许主线程等待线程结束

    print ‘all DONE‘

if __name__ == ‘__main__‘:  # 独立运行脚本
    main()
时间: 2024-11-05 20:46:32

《Python核心编程》18.多线程编程(三)的相关文章

18 多线程编程 - 《Python 核心编程》

?? 引言/动机 ?? 线程和进程 ?? 线程和 Python ?? thread 模块 ?? threading 模块 ?? 生产者-消费者问题和 Queue 模块 ?? 相关模块 18.1 引言/动机 18.2 线程和进程 什么是进程? 计算机程序只不过是磁盘中可执行的,二进制(或其它类型)的数据.它们只有在被读取到内 存中,被操作系统调用的时候才开始它们的生命期.进程(有时被称为重量级进程)是程序的一次 执行.每个进程都有自己的地址空间,内存,数据栈以及其它记录其运行轨迹的辅助数据.操作系

[.net 面向对象程序设计进阶] (18) 多线程(Multithreading)(三) 利用多线程提高程序性能(下)

[.net 面向对象程序设计进阶] (18) 多线程(Multithreading)(二) 利用多线程提高程序性能(下) 本节导读: 上节说了线程同步中使用线程锁和线程通知的方式来处理资源共享问题,这些是多线程的基本原理. .NET 4.0以后对多线程的实现变得更简单了. 本节主要讨论.NET4.0多线程的新特性——使用Task类创建多线程. 读前必备: A. LINQ使用  [.net 面向对象编程基础] (20) LINQ使用 B. 泛型          [.net 面向对象编程基础] (

廖雪峰Java13网络编程-1Socket编程-3TCP多线程编程

TCP多线程编程 一个ServerSocket可以和多个客户端同时建立连接,所以一个Server可以同时与多个客户端建立好的Socket进行双向通信. 因此服务器端,当我们打开一个Socket以后,通常使用一个无限for循环,在这个for循环内部,每次调用accept方法,返回一个与远程客户新建的Socket连接,紧接着启动一个新的线程,来处理这个连接. ServerSocket ss = new ServerSocket(port); for( ; ; ){ Socket sock = ss.

《Python核心编程》18.多线程编程(二)

18.1没有线程支持 #!/usr/bin/env python # -*- coding:utf-8 -*- from time import sleep, ctime def loop0(): print 'start loop 0 at:', ctime() sleep(4) print 'loop 0 done at', ctime() def loop1(): print 'start loop 1 at:', ctime() sleep(2) print 'loop 1 done a

《Python核心编程》 18.多线程编程(一)

一进程和线程 1参考链接: http://www.zhihu.com/question/25532384 中OF小工和zhonyong 的回答 总结他们两的回答: 引言: 1.电脑的运行,在硬件上是CPU.相关寄存器.RAM之间的事情.负责处理任务的顺序有CPU决定. 2.程序的上下文:当CPU处理任务时,所需要的各种资源(显卡.寄存器等)准备完毕,构成了这个程序的执行环境,即上下文. 3.CPU处理任务顺序:先加载程序A的上下文,然后开始执行A,保存程序A的上下文,调入下一个要执行的程序B的程

python核心编程(多线程编程)

1.全局解释器锁 2.threading模块 thread类 原文地址:https://www.cnblogs.com/goobai/p/8689060.html

python并发编程之多线程编程

一.threading模块介绍 multiprocess模块的完全模仿了threading模块的接口,二者在使用层面,有很大的相似性,因而不再详细介绍 二.开启线程的两种方式 方式一: from threading import Thread import time import random def task(name): print('%s is running' %name) time.sleep(random.randint(1,3)) print('%s is end' %name)

《Python核心编程》 第3版 中文版pdf

下载地址:网盘下载 内容简介 编辑 Python是一种功能十分强大的面向对象编程语言,可以用于编写独立程序.快速脚本和复杂应用的原型.作为一种开源软件,Python可以自由获取,而且非常易学易用.本书是Python语言的经典入门读本,由两名顶尖的Python技术专家兼培训专家联手撰写,涵盖了该语言的所有核心内容.所有练习的解答都可在书后找到. 本书描述了Python程序的基本构件:类型.操作符.语句.函数.模块.类以及异常和介绍了更多高级主题,包括复杂的实例.无论是用于编写简单的脚本,还是复杂的

python核心编程第二版

初学Python这是一本有关Python开发的指南涵盖近期发布的Pyttlon版本的核心功能特性,而不仅仅是语法学习更多的高阶内容,如正则表达式.网络.多线程.图形用户界面.Web/CGl和Python扩展等包括几个全新的章节,关于数据库.网络客户端.Java/Jytt30n和Microsoft Office等 展示数以百计的代码片段.交互实例和大量加强您的Python技能的实用练习"对Wesley Chun<Python核心编程>第二版的漫长等待是值得的--它的深邃.它的全面,以及