Python-多线程编程

threading 模块

threading 模块的对象

Thread 类

创建实例

启动一个线程就是把一个函数传入并创建Thread实例,然后调用start()开始执行

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

import threading
import time

def loop():
    strat_time = time.time()
    print('thread %s is running...' % threading.current_thread().name) #当前进程名
    n = 0
    while n < 5:
        n = n + 1
        print('thread %s >>> %s' % (threading.current_thread().name, n))
        time.sleep(1)
    print('thread %s ended.' % threading.current_thread().name)
    end_time = time.time()
    all_time = end_time - strat_time
    print("共用时:%s" % all_time)


print('thread %s is running...time = %s' % (threading.current_thread().name,time.ctime()))
t = threading.Thread(target=loop, name='LoopThread') # 创建Thread实例
t.start()   # 开始执行
t.join()    # 阻塞主线程
print('thread %s ended. time = %s ' % (threading.current_thread().name,time.ctime()))

多线程和多进程最大的不同在于,多进程中,同一个变量,各自有一份拷贝存在于每个进程中,互不影响,Lock
而多线程中,所有变量都由所有线程共享,所以,任何一个变量都可以被任何一个线程修改,

因此,线程之间共享数据最大的危险在于多个线程同时改一个变量,把内容给改乱了。

一个用lock解决的示例代码

import time, threading

# 假定这是你的银行存款:
balance = 0
lock=threading.Lock()   #创建锁

def change_it(n):
    # 先存后取,结果应该为0:
    global balance
    balance = balance + n
    balance = balance - n

def run_thread(n):
    for i in range(100000):
        lock.acquire()  # 申请锁
        try:
            change_it(n)
        finally:
            lock.release()  # 释放锁

t1 = threading.Thread(target=run_thread, args=(5,))
t2 = threading.Thread(target=run_thread, args=(8,))

t1.start()
t2.start()

t1.join()
t2.join()

print("The Res is %d" % balance)

queue模块,提供线程间通信的机制,从而让线程之间可以互相分享数据生产者-消费者问题和queue模块
具体而言,就是创建一个队列,让生产者(线程)在其中放入新的商品,而消费者(线程)消费这些商品
queue

模块常用属性

MyThread.py

#!/usr/bin/env python

import threading
from time import ctime


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

    def run(self):
        print('开始执行', self.name, ' 在:', ctime())
        self.res = self.func(*self.args)
        print(self.name, '结束于:', ctime())

    def getResult(self):
        return self.res

product.py

#!/usr/bin/env python
# -*- coding:utf8 -*-
from random import randint
from time import sleep
from queue import Queue
from MyThread import MyThread


# 将一个对象放入队列中
def writeQ(queue):
    print('正在为队列生产………')
    queue.put('商品', 1)
    print('当前商品总数:', queue.qsize())


# 消费队列中的一个对象
def readQ(queue):
    val = queue.get(1)
    print('正在从队列中消费商品……消费后还剩余商品:', queue.qsize())


# 模仿生产者。
def writer(queue, loops):
    for i in range(loops):
        writeQ(queue)
        sleep(randint(1, 3))  # writer的睡眠时间一般比reader短,是为了阻碍 reader从空队列中获取对象,换句话说就是使得轮到reader执行时,已存在可消费对象的可能性更大。


# 模仿消费者
def reader(queue, loops):
    for i in range(loops):
        readQ(queue)
        sleep(randint(2, 5))


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


def main():
    nloops = randint(2, 5)  # randint 和randrange类似,区别在于,randrange是半开半闭区间,而randint是闭区间
    q = Queue(32)

    threads = []  # 模拟线程池
    for i in nfuncs:
        t = MyThread(funcs[i], (q, nloops), funcs[i].__name__)  # 创建线程
        threads.append(t)

    for i in nfuncs:
        threads[i].start()  # 开始执行线程

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

    print('结束')


if __name__ == '__main__':
    main()

配合此篇大纲学习,效果更佳:Python黑客编程之极速入门

-------------本文结束❤感谢阅读-------------

本文标题:Python-多线程编程

文章作者:MaiKeFee

发布时间:2019年09月19日

最后更新:2019年09月19日

原始链接:http://MaiKeFee.com/archives/64be7bf2.html