多线程讲解+ Python thread实战操作

有勇气的牛排 270 Python 2023-05-18 20:51:24

哈喽，大家好，我是有勇气的牛排（全网同名）🐮🐮🐮

有问题的小伙伴欢迎在文末评论，点赞、收藏是对我最大的支持！！！。

一、前言

1. 什么是线程

线程（Thread）也被称为轻量级进程，是操作系统能够进行调度的最小单位，它被包含在进行中，是进程中的实际运作单位。线程本身不拥有系统资源，但是与同进程中的其他线程共享进程资源。

一个进程中的多个线程可以创建和kill另一个线程，同一个进程中的多个线程之间可以并发执行。

2. 进程与线程

进程是资源分配的最小单位，一个程序至少有一个进程。
线程称程序执行的最小单位，一个进程至少有一个线程。

进程都有自己的独立地址空间、内存、数据栈等，所以进程占用资源多。由于进程的资源独立，通信不方便，故而进程间使用IPC通讯。

一个进程中可以存在多个线程，在单核CPU中每隔进程中同时只能运行一个线程，所以只有在多核CPU中在能实现多线程并发。

3. 为什么要用多线程

线程在程序中是独立，并且并发的执行流。与进程相比，进程中线程之间的隔离程度要小，其可以共享内存、文件句柄等。

线程的划分尺度小于进程，使得多线程的并发性要高。而进程在执行的过程中，系统会为其分配独立的内存单元，而线程内存共享，故而效率极大地得到了提升。

线程

二、 Python 多线程

1. 线程间等待 join

from time import sleep
from threading import Thread
import threading

# 小明要下载10个视频
tasks = ['move1','movie2','movie3','movie4','movie5','movie6']

def download(movie):
    # print(f'开始下载{movie}')
    sleep(2)
    print(f'完成下载{movie}')

threads = []
for task in tasks:
    t = Thread(target=download, name=task,args=(task,))
    t.start()   # 启动线程
    threads.append(t)

for t in threads:
    t.join()    # 当前线程等待线程 t 执行完成后再执行后面的代码

print(threading.current_thread())
print('完成')

2. 其他

from time import sleep
from threading import Thread
import threading

# 小明要下载10个视频
tasks = ['move1','movie2','movie3','movie4','movie5','movie6']

def download(movie):
    # print(f'开始下载{movie}')
    sleep(2)
    # print(f'完成下载{movie}')

for task in tasks:
    # 创建线程
    # daemon :守护线程---当主线程执行完成后，马上终止当前的任务，不管是否完成。
    t = Thread(target=download, name=task,args=(task,))
    t.start()       # 启动线程
    print(f'{t.name},{t.ident},{t.is_alive()},{t.daemon}')


print(threading.current_thread())
print('完成')

3. 完整

import threading
import time

from queue import Queue

def job(l,q):
    for i in range (len(l)):
        l[i] = l[i]**2
    q.put(l)

def multithreading():
    q =Queue()
    threads = []
    data = [[1,2,3],[3,4,5],[4,4,4],[5,5,5]]
    for i in range(4):
        t = threading.Thread(target=job,args=(data[i],q))
        t.start()
        threads.append(t)
    for thread in threads:
        thread.join()

    results = []
    for _ in range(4):
        results.append(q.get())
    print(results)

if __name__=='__main__':
    multithreading()

4. 需求：主线程跑的时候，再开启个子线程，无需子线程的结果，相互独立


import threading, time

def T1():
    time.sleep(3)
    print(666)

def main():
    # 添加线程
    thread = threading.Thread(target=T1, name='T1')
    thread.start()

    print(123)
    return '6'

if __name__ == '__main__':
    main()

参考：
https://blog.csdn.net/qq_16481211/article/details/80950979

哈喽，大家好，我是有勇气的牛排（全网同名）🐮🐮🐮 有问题的小伙伴欢迎在文末评论，点赞、收藏是对我最大的支持！！！。 <h2><a id="__4"></a>一、前言</h2> <h3><a id="1__5"></a>1. 什么是线程</h3> 线程（Thread）也被称为轻量级进程，是操作系统能够进行调度的最小单位，它被包含在进行中，是进程中的实际运作单位。线程本身不拥有系统资源，但是与同进程中的其他线程共享进程资源。 一个进程中的多个线程可以创建和kill另一个线程，同一个进程中的多个线程之间可以并发执行。 <h3><a id="2__11"></a>2. 进程与线程</h3> 进程是资源分配的最小单位，一个程序至少有一个进程。 线程称程序执行的最小单位，一个进程至少有一个线程。 进程都有自己的独立地址空间、内存、数据栈等，所以进程占用资源多。由于进程的资源独立，通信不方便，故而进程间使用IPC通讯。 一个进程中可以存在多个线程，在单核CPU中每隔进程中同时只能运行一个线程，所以只有在多核CPU中在能实现多线程并发。 <h3><a id="3__19"></a>3. 为什么要用多线程</h3> 线程在程序中是独立，并且并发的执行流。与进程相比，进程中线程之间的隔离程度要小，其可以共享内存、文件句柄等。 线程的划分尺度小于进程，使得多线程的并发性要高。而进程在执行的过程中，系统会为其分配独立的内存单元，而线程内存共享，故而效率极大地得到了提升。 线程 <h2><a id="_Python__26"></a>二、 Python 多线程</h2> <h3><a id="1__join_27"></a>1. 线程间等待 join</h3> <pre><div class="hljs"><code class="lang-python">from time import sleep from threading import Thread import threading # 小明要下载10个视频 tasks = ['move1','movie2','movie3','movie4','movie5','movie6'] def download(movie): # print(f'开始下载{movie}') sleep(2) print(f'完成下载{movie}') threads = [] for task in tasks: t = Thread(target=download, name=task,args=(task,)) t.start() # 启动线程 threads.append(t) for t in threads: t.join() # 当前线程等待线程 t 执行完成后再执行后面的代码 print(threading.current_thread()) print('完成') </code></div></pre> <h3><a id="2__56"></a>2. 其他</h3> <pre><div class="hljs"><code class="lang-python">from time import sleep from threading import Thread import threading # 小明要下载10个视频 tasks = ['move1','movie2','movie3','movie4','movie5','movie6'] def download(movie): # print(f'开始下载{movie}') sleep(2) # print(f'完成下载{movie}') for task in tasks: # 创建线程 # daemon :守护线程---当主线程执行完成后，马上终止当前的任务，不管是否完成。 t = Thread(target=download, name=task,args=(task,)) t.start() # 启动线程 print(f'{t.name},{t.ident},{t.is_alive()},{t.daemon}') print(threading.current_thread()) print('完成') </code></div></pre> <h3><a id="3__83"></a>3. 完整</h3> <pre><div class="hljs"><code class="lang-python">import threading import time from queue import Queue def job(l,q): for i in range (len(l)): l[i] = l[i]**2 q.put(l) def multithreading(): q =Queue() threads = [] data = [[1,2,3],[3,4,5],[4,4,4],[5,5,5]] for i in range(4): t = threading.Thread(target=job,args=(data[i],q)) t.start() threads.append(t) for thread in threads: thread.join() results = [] for _ in range(4): results.append(q.get()) print(results) if __name__=='__main__': multithreading() </code></div></pre> <h3><a id="4__117"></a>4. 需求：主线程跑的时候，再开启个子线程，无需子线程的结果，相互独立</h3> <pre><div class="hljs"><code class="lang-python"> import threading, time def T1(): time.sleep(3) print(666) def main(): # 添加线程 thread = threading.Thread(target=T1, name='T1') thread.start() print(123) return '6' if __name__ == '__main__': main() </code></div></pre> 参考： https://blog.csdn.net/qq_16481211/article/details/80950979