线程和线程池

最新推荐文章于 2024-03-16 14:11:46 发布

0&1 * 1

最新推荐文章于 2024-03-16 14:11:46 发布

阅读量246

点赞数 2

分类专栏： python 文章标签：线程和线程池

本文链接：https://blog.csdn.net/weixin_44820920/article/details/100940879

版权

python 专栏收录该内容

34 篇文章 0 订阅

订阅专栏

线程和线程池

一、线程简介

1）线程简介

1.python—>编程语言---->开发应用程序
程序：1.驱动程序，比如显卡驱动程序 2.操作系统，比如windows系统 3.应用程序，比如qq

应用程序，存储在硬盘上的二进制文件，只有被加载到内存空间的时候，它才具备生命周期

进程就是一个运行中的应用程序

每一个进程默认启动一个线程，这个线程叫做主线程，线程属于进程。

2）线程的实现

1.线程模块

Python通过两个标准库_thread 和threading
提供对线程的支持 , threading对_thread进行了封装。
threading模块中提供了Thread , Lock , RLock , Condition等组件。
因此在实际的使用中我们一般都是使用threading

2.Thread

[外链图片转存失败(img-P8OvD1bm-1568727516294)(…/…/…/…/…/…/Desktop/Data/Python_note/work.md/photo/23.png)]

1.from threading import Thread
import time


def f1(people):
    print("hello，{}".format(people))
    time.sleep(3)
    print("bye")


def f2():
    print("hi")
    time.sleep(3)
    print("goodbye")


if __name__ == '__main__':
    # 正常调用，是有先后顺序，主线程
    # f1()
    # f2()
    # 线程操作
    f1_thread = Thread(target=f1, args=("胡歌",), name='hello')  # 创建了一个线程实例
    f2_thread = Thread(target=f2, name='hi')   # 实例对象时，函数并未执行

    f1_thread.setName("dai")
    f1_thread.setName("hu")

    print("f1 name:", f1_thread.getName())
    print("f2 name:", f2_thread.getName())

    # f1_thread.setDaemon(True)
    # f2_thread.setDaemon(True)

    # f1_thread.start()   # 调用start方法才开始执行
    # f2_thread.start()

    # f1_thread.join()  # 阻塞调用，主线程进行等待
    # f2_thread.join()

    print("主线程执行完毕")

"""
主线程执行完毕了，但是子线程依然没有关闭，程序一直无法关闭
守护线程：主线程执行完毕后，程序就关闭
"""

2.from threading import Thread
import time


# class MyThread(Thread):
#     def run(self):
#         print('hello')
#         time.sleep(3)
#         print('bye')
#
#
# my_thread = MyThread()  # 创建一个线程实例
# my_thread.start()

# 重写了类中run方法，通过start方法自动去调用类中的run方法

class MyThread(Thread):
    def __init__(self, people, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.people = people

    def run(self):
        print('hello，{}'.format(self.people))
        time.sleep(3)
        print('bye')


my_thread = MyThread("齐时久", name="hello")  # 创建一个线程实例
print(my_thread.getName())
my_thread.start()

3.创建线程

1（在python中创建线程有两种方式,实例Thread类和继承重写Thread类

实例Thread类

2（[外链图片转存失败(img-7ivm83nv-1568727516295)(…/…/…/…/…/…/Desktop/Data/Python_note/work.md/photo/24.png)]

3（继承Thread类

[外链图片转存失败(img-hZMy3PPT-1568727516295)(…/…/…/…/…/…/Desktop/Data/Python_note/work.md/photo/25.png)]

4（Join & setDaemon

在说这两个方法之前 , 需要知道主线程与子线程的概念

主线程 : 当一个程序启动时 , 就有一个线程开始运行 , 该线程通常叫做程序的主线程

子线程 : 因为程序是开始时就执行的 , 如果你需要再创建线程 , 那么创建的线程就是这个主线程的子线程

主线程的重要性体现在两方面 : 
1. 是产生其他子线程的线程 
2. 通常它必须最后完成执行比如执行各种关闭操作

5（join : 阻塞调用程序 , 直到调用join () 方法的线程执行结束, 才会继续往下执行

[外链图片转存失败(img-brvDhADK-1568727516296)(…/…/…/…/…/…/Desktop/Data/Python_note/work.md/photo/26.png)]

6（setDaemon() 与 join() 基本上是相对的 , join会等子线程执行完毕 ; 而setDaemon则不会等

[外链图片转存失败(img-HuN9FdLD-1568727516296)(…/…/…/…/…/…/Desktop/Data/Python_note/work.md/photo/27.png)]

二、线程间的资源共享

1）互斥锁

1.在多线程中 , 所有全局变量对于所有线程都是共享的 , 因此 , 线程之间共享数据最大的危险在于多个线程同时修改一个变量 , 那就乱套了 , 所以我们需要互斥锁 , 来锁住数据。

from threading import Thread, Lock

data = 0


def add_1():
    global data
    lock.acquire()
    for i in range(1000000):
        data += 1
    lock.release()


def red_1():
    global data
    lock.acquire()
    for i in range(1000000):
        data -= 1
    lock.release()


if __name__ == '__main__':
    # 正常执行，结果为0
    # add_1()
    # red_1()
    # print(data)
    lock = Lock()
    # 线程操作
    t1 = Thread(target=add_1)
    t2 = Thread(target=red_1)
    t1.start()
    t2.start()
    t1.join()
    t2.join()
    print(data)

"""
data += 1
x = data + 1
data = x

data = 0
t1: x1 = data + 1 # x1 = 0 + 1 = 1
t2: x2 = data - 1 # x2 = 0 - 1 = -1
t1: data = x1 = 1
t2: data = x2 = -1

结果：data = -1
"""

2）线程间全局变量的共享

1.提示！
因为线程属于同一个进程，因此它们之间共享内存区域。
因此全局变量是公共的。

[外链图片转存失败(img-nejhngXC-1568727516297)(…/…/…/…/…/…/Desktop/Data/Python_note/work.md/photo/28.png)]

3）共享内存间存在竞争问题

1.提示！
如果1000000不能出现效果
可以继续在后面加0

[外链图片转存失败(img-aIm7n6jH-1568727516297)(…/…/…/…/…/…/Desktop/Data/Python_note/work.md/photo/29.png)]

3.[外链图片转存失败(img-U2d9s69K-1568727516297)(…/…/…/…/…/…/Desktop/Data/Python_note/work.md/photo/30.png)]

from threading import Thread

a = 5


def f():
    print('我是子线程，我要修改全局的变量值')
    global a
    a = 2


if __name__ == '__main__':
    print('我是主线程，变量a的值是{}'.format(a))
    t = Thread(target=f)
    t.start()
    t.join()
    print('我是主线程，变量a的值是{}'.format(a))

# 全局变量被所有子线程共享的。资源竞争

4）使用锁来控制共享资源的访问

[外链图片转存失败(img-ENJkv7WB-1568727516298)(…/…/…/…/…/…/Desktop/Data/Python_note/work.md/photo/31.png)]

5）线程队列操作

1.入队： put(item)

2.出队： get()

from threading import Thread
from queue import Queue
from random import randint

my_queue = Queue(10)    # 创建队列对象，指定队列长度


def my_put(my_queue):
    """往队列塞东西"""
    for x in range(10):
        num = randint(0, 1000)
        my_queue.put(num)


def my_get(my_queue):
    """往队列拿东西"""
    for y in range(3):
        num = my_queue.get()
        print(num)


p = Thread(target=my_put, args=(my_queue,))
g = Thread(target=my_get, args=(my_queue,))
p.start()
g.start()
p.join()
g.join()

3.测试空： empty() # 近似

4.测试满： full() # 近似

5.队列长度： qsize() # 近似

6.任务结束： task_done()

from queue import Queue

my_queue = Queue(3)

if __name__ == '__main__':
    my_queue.put(1)
    print(my_queue.qsize())
    my_queue.get()
    print(my_queue.qsize())
    print(my_queue.empty())
    my_queue.put(1)
    my_queue.put(1)
    my_queue.put(1)
    print(my_queue.full())
    my_queue.task_done()    # 任务结束
    my_queue.task_done()    # 任务结束
    my_queue.task_done()    # 任务结束
    my_queue.task_done()    # 任务结束
    my_queue.join()  # 等待完成，用来判断task_done的次数是否和put的次数一致
    print("任务结束")
    
    from threading import Thread, current_thread
from queue import Queue
import time
from multiprocessing.pool import ThreadPool

# class ThreadPool(object):
#     def __init__(self, n):  # 参数n是可重复使用的线程数
#         # 生成一个队列，里面放任务
#         self.q = Queue(n)
#         # 生成线程
#         for i in range(n):
#             Thread(target=self.worker, daemon=True).start()
#
#     def worker(self):
#         """实现从队列里取任务完成"""
#         while True:  # 死循环，这样线程才会一直不结束，一直使用下去
#             func, args, kwargs = self.q.get()   # 从队列去取任务
#             func(*args, **kwargs)   # 运行刚得到的任务
#             self.q.task_done()  # 执行完，通知队列
#
#     def put_q(self, func, args=(), kwargs={}):
#         """实现往队列里放任务"""
#         self.q.put((func, args, kwargs))
#
#     def join_q(self):
#         self.q.join()   # 阻塞，等待完成

7.等待完成： join()

三、线程池

1）池的概念

1.主线程：相当于生产者，只管向线程池提交任务。
并不关心线程池是如何执行任务的。
因此，并不关心是哪一个线程执行的这个任务。

2.线程池：相当于消费者，负责接收任务，
并将任务分配到一个空闲的线程中去执行。

3. 在这里插入图片描述

2）线程池简单实现

在这里插入图片描述

3）效果实现

在这里插入图片描述

4）python内置线程池

在这里插入图片描述

5）池的其他操作

1.操作一： close - 关闭提交通道，不允许再提交任务

2.操作二： terminate - 中止

0&1 * 1

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
线程和线程池

线程和线程池一、线程简介1）线程简介1.python—>编程语言---->开发应用程序程序：1.驱动程序，比如显卡驱动程序 2.操作系统，比如windows系统 3.应用程序，比如qq应用程序，存储在硬盘上的二进制文件，只有被加载到内存空间的时候，它才具备生命周期进程就是一个运行中的应用程序每一个进程默认启动一个线程，这个线程叫做主线程，线程属于进程。2）线程的实现1...
复制链接

扫一扫