Python中线程的创建

最新推荐文章于 2024-09-17 08:29:36 发布
最新推荐文章于 2024-09-17 08:29:36 发布
阅读量564 收藏 5
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42725815/article/details/86633633
版权

一 创建线程

import  threading
import time
def job():
    print("这是一个需要执行的任务")
    # 激活的线程个数
    print("当前线程的个数:", threading.active_count())
    # 打印当前线程的详细信息
    print("当前线程信息:", threading.current_thread())
    time.sleep(10)

if __name__ == "__main__":
    job()

在这里插入图片描述

二 创建多线程

1._thread方式创建多线程

import _thread
import threading
import time

def job(name):
    print("这是一个需要执行的任务")
    # # 激活的线程个数
    # print("当前线程的个数:", threading.active_count())
    # # 打印当前线程的详细信息
    # print("当前线程信息:", threading.current_thread())
    print(name, time.ctime())
    time.sleep(2)
if __name__ == "__main__":
    # 创建多个线程, 但是没有开始执行任务；
    _thread.start_new_thread(job,('thread1', ))
    _thread.start_new_thread(job,('thread2', ))
    while True:
        pass

在这里插入图片描述
2.threading方式创建多线程

import _thread
import threading
import time
def job(name):
    print('这是一个需要执行的任务: %s' %(name))
    #激活的线程个数
    print('当前线程的个数:',threading.active_count())
    #打印当前线程的详细信息
    print('当前线程信息:',threading.current_thread())
    time.sleep(3)
    print(name,time.ctime())
if __name__=='__main__':
    job('job0')
    #创建多个线程
    t1=threading.Thread(target=job,name='job1',args=('job1-name',))
    t1.start()
    t2=threading.Thread(target=job,name='job2',args=('job2-name',))
    t2.start()
    print('hello')

在这里插入图片描述

三 多线程的JOIN方法

不使用多线程

import time
def music(name):
    for i in range(2):
        print('正在听音乐%s' %(name))
        time.sleep(1)
def code(name):
    for i in range(2):
        print('正在编写代码%s' %(name))
        time.sleep(2)
if __name__=='__main__':
    start_time=time.time()
    music('That girl')
    code('爬虫')
    print('花费时间:%s' %(time.time()-start_time))

在这里插入图片描述
结论：事情是一个一个的做，没有同时进行，但是我敲代码的时候是会听歌的，因此此处可以使用多线程来处理的

使用多线程

import threading
import time
def music(name):
    for i in range(2):
        print('正在听音乐%s' %(name))
        time.sleep(1)
def code(name):
    for i in range(2):
        print('正在编写代码%s' %(name))
        time.sleep(2)
if __name__=='__main__':
    start_time=time.time()
    t1=threading.Thread(target=music,args=('That girl',))
    t2=threading.Thread(target=code,args=('爬虫',))
    t1.start()
    t2.start()
    print('花费时间:%s' %(time.time()-start_time))

在这里插入图片描述
结论：发现时间确实是变快了好多，但是感觉跟想象的不太一样，执行时间都结束了，而事情却没做完，这是因为主线程阻塞了子线程进行，接着我们需要引入join方法


import threading
import time
def music(name):
    for i in range(2):
        print('正在听音乐%s' %(name))
        time.sleep(1)
def code(name):
    for i in range(2):
        print('正在编写代码%s' %(name))
        time.sleep(2)
if __name__=='__main__':
    start_time=time.time()
    t1=threading.Thread(target=music,args=('That girl',))
    t2=threading.Thread(target=code,args=('爬虫',))
    t1.start()
    t2.start()
    #等待所有的子线程执行结束之后，继续执行主线程的内容
    t1.join()
    t2.join()
    print('花费时间:%s' %(time.time()-start_time))

在这里插入图片描述
join方法是使程序等待所有的子线程执行结束之后， 继续执行主线程的内容，即等待，直到t1线程执行结束;其间阻塞正在调用的线程。

四 threading的set_daemon方法

当主线程执行结束， 让没有执行的线程强制结束;set_daemon

import threading
import time
#任务一
def music(name):
    for i in range(2):
        print('正在听音乐%s' %(name))
        time.sleep(1)
#任务二
def code(name):
    for i in range(2):
        print('正在编写代码%s' %(name))
        time.sleep(2)
if __name__=='__main__':
    start_time=time.time()
    t1=threading.Thread(target=music,args=('That girl',))
    t2=threading.Thread(target=code,args=('爬虫',))
    #将t1线程为守护线程,如果设置True,子线程启动,当主线程执行结束,子线程也结束
    #设置setDaemon必须在启动线程之前进行设置
    t1.setDaemon(True)
    t2.setDaemon(True)
    t1.start()
    t2.start()
    print('花费时间:%s' %(time.time()-start_time))

在这里插入图片描述

五 继承的方法创建多线程

1.任务无需任何参数
在这里插入图片描述
2.任务需要参数

import json
import threading
#类的继承
from urllib.error import HTTPError
from urllib.request import urlopen

import time

class IpThread(threading.Thread):
    # 重写构造方法;如果执行的任务需要传递参数,那将参数通过构造函数与self绑定;
    def __init__(self, jobname, ip):
        super(IpThread, self).__init__()
        self.jobname = jobname
        self.ip = ip
        # 将多线程需要执行的任务重写到run方法中;
    def run(self):
        try:
            # 需要有一个参数，传ip;
            url = "http://ip.taobao.com/service/getIpInfo.php?ip=%s" % (self.ip)
            # 根据url获取网页的内容， 并且解码为utf-8格式， 识别中文;
            text = urlopen(url).read().decode('utf-8')
        except HTTPError as e:
            print("Error: %s获取地理位置网络错误" %(self.ip))
        else:
            # 将获取的字符串类型转换为字典，方便处理
            d = json.loads(text)['data']
            country = d['country']
            city = d['city']
            print("%s:" % (self.ip), country, city)
def use_thread():
    start_time = time.time()
    ips = ['172.25.254.250', '8.8.8.8',
           '172.25.254.250', '8.8.8.8',
           '172.25.254.250', '8.8.8.8']
    threads = []
    for ip in ips:
        t = IpThread(jobname="爬虫", ip=ip)
        threads.append(t)
        t.start()
    # 等待所有的子线程执行结束
    [thread.join() for thread in threads]
    print("Success, 运行时间为%s" % (time.time() - start_time))

if __name__ == "__main__":
    use_thread()

在这里插入图片描述

六 线程锁

多个线程对同一个数据进行修改时，最大的危险在于把内容给改乱，如下：

import threading
def add():
    global money
    for i in range(1000000):
        money+=1
def reduce():
    global money
    for i in range(1000000):
        money-=1
if __name__=='__main__':
    money=0
    t1 = threading.Thread(target=add)
    t2 = threading.Thread(target=reduce)
    t1.start()
    t2.start()
    #等待所有子线程执行结束
    t1.join()
    t2.join()
    print("最终金额为:%s" % (money))

在这里插入图片描述
分析：理论上money的值应该为0，但是，由于线程的调度是由操作系统决定的，当t1、t2交替执行时，只要循环次数足够多，money的结果就不一定是0了
原因：高级语言的一条语句在CPU执行时是若干条语句，即使一个简单计算money+=1 也是分为两步去完成的，先计算 money+1，将结果存入临时变量，再将临时变量赋值给money，而两个线程都拥有各自的临时变量，当t1与t2交替执行的时候，就会导致把同一个对象给改的混乱
所以我们对其进行加锁：线程锁lock

import threading

def add(lock):
    # 2.操作变量之前进行加锁
    lock.acquire()
    global money
    for i in range(1000000):
        money += 1
    # 3.操作变量完成后进行解锁
    lock.release()

def reduce(lock):
    # 2.操作变量之前进行加锁
    lock.acquire()
    global  money
    for i in range(1000000):
        money -= 1
    # 3.操作变量完成后进行解锁
    lock.release()

if __name__ == '__main__':
    money = 0
    # 1. 实例化一个锁对象
    lock = threading.Lock()
    t1 = threading.Thread(target=add, args=(lock, ))
    t2 = threading.Thread(target=reduce, args=(lock, ))
    t1.start()
    t2.start()
    # 等待所有子线程执行结束
    t1.join()
    t2.join()
    print("最终金额为:%s" %(money))

在这里插入图片描述
线程锁的本质：对同一对象进行操作时，一个线程在进行前加把锁，让其他线程不能对其进行操作，执行完成后，再进行解锁释放

七 Python中的GIL全局解释器锁

  • GIL(全局解释器锁)
  • python解释器默认每次只允许一个线程执行
    执行过程:
    1). 设置GIL
    2). 切换到线程去运行对应的任务;
    3). 运行
    -执行完了
    -time.sleep()
    -获取其他信息才能继续执行, eg: 从网络上获取网页信息等;
    4). 把线程设置为睡眠状态
    5). 解锁GIL
    6). 再次重复执行上述内容
    方法的选择：
    Python并不支持真正意义上的多线程。Python中提供了多线程包，但是如果你想通过多线程提高代码的速度，使用多线程包并不是个好主意。
    Python中有一个被称为Global Interpreter Lock（GIL）的东西，它会确保任何时候你的多个线程中，只有一个被执行。线程的执行速度非常之快，会让你误以为线程是并行执行的，但是实际上都是轮流执行。
    经过GIL这一道关卡处理，会增加执行的开销。这意味着，如果你想提高代码的运行速度，使用threading包并不是一个很好的方法。
import threading
from mytimeit import timeit
def job(l):
    sum(l)

@timeit
def use_thread():
    li = range(1,10000)
    for i in range(5):
        t = threading.Thread(target=job, args=(li, ))
        t.start()
@timeit
def use_no_thread():
    li = range(1, 10000)
    for i in range(5):
        job(li)

if __name__ == "__main__":
    use_thread()
    use_no_thread()

在这里插入图片描述
mytime模块中的timeit装饰器：

import time

def timeit(f):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        res = f(*args, **kwargs)
        end_time = time.time()
        print("%s运行时间为%s" %(f.__name__, end_time-start_time))
        return  res
    return  wrapper

八 队列与多线程

1).理论上多线程执行任务， 会产生一些数据， 为其他程序执行作铺垫;
2). 多线程是不能返回任务执行结果的， 因此需要一个容器来存储多线程产生的数据
3). 这个容器如何选择? list(栈， 队列), tuple(x), set(x), dict(x)， 此处选择队列来实现

import threading
from collections import Iterable

from mytimeit import timeit
from queue import  Queue

def job(l, queue):
    # 将任务的结果存储到队列中;
    queue.put(sum(l))
@timeit
def use_thread():
    # 实例化一个队列， 用来存储每个线程执行的结果;
    q = Queue()
    # 入队
    # q.put(1)
    li = [[1,2,3,4,5], [2,3,4,5,6], [2,3,4,5,6,7,8], [2,3,4,5,6]]
    threads = []
    for i in li:
        t = threading.Thread(target=job, args=(i, q))
        threads.append(t)
        t.start()

    # join方法等待所有子线程执行结束
    [thread.join() for thread in threads]
    # 从队列里面拿出所有的运行结果
    result = [q.get() for _ in li]
    print(result)
    print(isinstance(q, Iterable))

if __name__ == "__main__":
    use_thread()

在这里插入图片描述

九 线程池

from concurrent.futures import ThreadPoolExecutor
import time
#需要执行的任务
def job():
    print('This is a job')
    return 'hello'
if __name__=='__main__':
    #实例化对象，线程池包含10个线程来处理任务
    pool=ThreadPoolExecutor(max_workers=10)
    #往线程池里面扔需要执行的任务， 返回一个对象，( _base.Future实例化出来的)
    f1=pool.submit(job)
    f2=pool.submit(job)
    #判断任务是否执行结束
    print(f1.done())
    time.sleep(1)
    print(f2.done())
    #获取任务执行的结果
    print(f1.result())
    print(f2.result())

在这里插入图片描述

十 线程池中的submit提交与map方法

from urllib.error import HTTPError
from urllib.request import urlopen
from concurrent.futures import ThreadPoolExecutor
from concurrent.futures import as_completed
import time
URLS = ['http://httpbin.org', 'http://example.com/',
        'https://api.github.com/'] * 50
def get_page(url, timeout=3):
    try:
        content = urlopen(url).read()
        return {'url':url, 'len':len(content)}
    except HTTPError as e:
        return {'url':url, 'len':0}

# 方法1： submit提交任务
start_time = time.time()
pool = ThreadPoolExecutor(max_workers=20)
futuresObj = [pool.submit(get_page, url) for url in URLS]

for future in futuresObj:
    print(future.result())

print("执行时间:%s" %(time.time()-start_time))

在这里插入图片描述
在这里插入图片描述
综上map处理的稍快一些，考虑到map更加简洁，推荐使用map处理。

木子葭
关注
〖Python语法进阶篇⑥〗- 线程的创建与常用方法
易编橙 · 终身成长社群，相遇已是上上签！
04-11 4万+
该章节我们要学习的是线程的使用，前面的学习我们知道进程的使用需要获取 CPU和内存 的资源，而线程则是利用进程的资源来执行业务，并且通过创建多个线程，对于资源的消耗相对来说会比较低，今天就来看一看线程的使用方法具体有哪些吧。
Python语法之线程的创建与用法
hdxx2022的博客
12-11 723
target 为创建线程时要执行的函数，而 args 为是要执行这个函数时需要传入的参数。通过上面的练习，我们发现进程的使用方法几乎与进程是一模一样的。它们都可以互不干扰的执行程序，也可以使得主线程的程序不需要等待子线程的任务完成之后再去执行。当多个线程同时修改文件一样会造成被修改文件的数据错乱的错误（因为都是并发去操作一个文件，特别是在处理交易场景的时候，需要尤为注意）。PS：通过上面的介绍，会发现其实线程对象里面的函数几乎和进程对象中的函数非常相似，它们的使用方法和使用场景几乎是相同的。
python 创建线程
后来者居上
02-21 755
在上面的代码中，worker 函数是线程需要执行的任务。然后我们使用 threading.Thread 类创建一个线程对象，并将 worker 函数作为参数传递给该对象的 target 参数。接下来，我们使用 start() 方法启动线程，使用 join() 方法等待线程执行完毕。 还有其他参数可以在创建线程时传递给 threading.Thread 类，例如 args 和 kwargs，这些参数将传递给 target 函数作为参数。 此外，还有一些高级的线程管理工具可以在 threading 模块中使
【Python基础编程】深入掌握线程与线程池的高效应用
最新发布
易辰的博客
09-17 1636
上篇文章讲述的是python的异常处理和文件读写，这篇文章讲述python的并发编程：线程。Python 中使用线程主要通过threading：创建新线程执行目标函数。start()：启动线程。join()：等待线程结束。Lock()：用于同步线程，避免竞态条件。是一种简单且强大的工具，用于在多线程环境中安全地共享数据。通过Queue，我们可以避免直接管理锁的复杂性，并实现线程安全的数据交换和任务分发。如果你需要处理线程间的数据交换、任务队列，Queue是首选。python 的和threading。
python创建线程
I need a job
08-28 510
########征服python############ 1. 使用T
python多线程接口案例
12-21
为了实现并发操作，将上述步骤（获取Cookie、登录、业务操作）封装到不同的函数中，然后利用Python的`threading`模块创建多个线程。每个线程代表一个并发的用户，执行相同的操作但可能带有不同的参数（如用户ID和...
python 多线程重启方法
09-19
本篇文章主要探讨的是如何在Python中实现多线程的自动重启机制，以确保即使有线程崩溃，程序也能继续执行。 首先，我们要了解Python的`Threading`模块，它是Python提供的标准库，用于处理多线程。`Threading.Thread...
详解Python多线程下的list
09-16
在Python编程中，多线程环境下对数据结构的操作是一个重要的考虑因素，特别是当涉及到共享数据时。本篇文章主要探讨了Python多线程下对列表(list)进行操作时的安全性问题。 首先，我们要明确一个概念：线程安全。...
Python 多线程，threading模块，创建子线程的两种方式示例
09-18
在Python的`threading`模块中创建子线程主要有两种方式： 1. 通过函数名指定子线程的任务。这种方式是将要执行的函数名通过`target`参数传递给`Thread`类的实例化对象，然后调用该实例的`start`方法来创建和启动...
python创建线程和结束线程
一键难忘的博客
04-22 3940
在 Python 中，线程是一种轻量级的执行单元，允许我们在程序中同时执行多个任务。线程的创建和结束是多线程编程中的核心概念之一。在本文中，我们将学习如何使用 Python 创建线程，并探讨如何优雅地结束线程。
Python 创建线程的两种方式
weixin_47906106的博客
11-26 887
Python 创建协程的方式主要有以下两种 Python3中提供了一个内置模块threating.Thred，可以非常方便的创建协程 threading.Thread() 一般接收两个参数： 线程函数名：线程执行的函数(任务)，由我们自已定义，注意不要加()； 线程函数的参数：线程函数名所需的参数，以元组的形式传入。若不需要参数，可以不指定(如果元组就一个参数要加逗号)。 使用Thread类的构造器创建线程 # 自定义线程要执行的函数 def test(par = 'jibu'): for info
Python 三种方法创建线程
ckk727的博客
08-19 3550
当需要处理多任务时，多线程编程比起多进程编程往往更有优势，每一个进程都至少有一个线程，一个进程多个线程就可以实现多个任务。线程是操作系统直接支持的执行单元。许多高级语言都支持多线程编程，Python也提供了多个模块支持多线程编程，包括_thread、threading、Queue等模块。 而想要创建一个线程，则需要用到其中的_thread、或者threading模块。 创建线程 Python标准库...
Python多线程（一）——创建多线程
重邮皮皮尛的博客
01-16 1478
python创建多线程。 1.通过 threading.Thread () 创建 2.通过继承 threading.Thread 类的继承
Python中的线程创建
villaaaaaaaa
09-25 1155
Python中的线程 一.创建线程 线程：CPU的基本调度单位，是程序执行流的最小单元，线程有就绪，阻塞和运行三种状态，就绪就是指线程具备所有的运行条件，逻辑上可以运行，只需等待CPU分配时间片即可，运行状态就是指线程占有CPU时间片，正在运行，阻塞是指线程在等待一个事件（如某个信号量），逻辑上不可执行，每一个程序至少有一个线程。线程是程序中一个单一的顺讯控制流程，进程内有一个相对独立的、可调度...
python 线程的创建与常用方法
yinge0508的博客
06-04 1492
线程的创建与常用方法
Python中的线程
weixin_30485799的博客
03-15 144
一、线程的概念 一个进程里面至少有一个控制线程，进程的概念只是一种抽象的概念，真正在CPU上面调度的是进程里面的线程,就好比真正在地铁这个进程里面工作的实际上是地铁里面的线程,北京地铁里面至少要有一个线程，线程是真正干活的，线程用的是进程里面包含的一堆资源,线程仅仅是一个调度单位，不包含资源。 什么时候需要开启多个线程：一个进程里面的多个线程共享这个进程里面的资...
Python线程操作-创建多线程教程
Python热爱者的博客
03-04 1165
Python提供了几个用于多线程的编程的模块，包括thread、threading和Queue等。thread和threading模块允许程序员创建和管理线程。thread模块提供了基本的线程和锁的支持，threading提供了更高级别、功能更强大的线程管理的功能。Queue模块允许用户创建一个可以用于多个线程之间共享输一局的队列数据结构。
Python多线程创建及threading模块详解
本文将深入探讨Python程序中创建多线程的过程，并特别关注如何利用Python的内置模块实现线程及其管理。首先，我们将介绍`thread`和`threading`这两个核心模块，以及为何推荐使用`threading`模块。 1.1 thread模块与...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值