欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

python之线程相关操作

程序员文章站 2022-07-03 11:17:07
1.线程: 一个进程可以有多个线程,共享一个进程的资源; 2.进程线程的区别: 进程是资源分配的最小单位,线程是程序执行的最小单位 3.python中线程模块threading, 提供的类: Thread, Lock, Rlock, Semaphore, Event, 等等 4.线程的创建方式 6. ......

1.线程: 一个进程可以有多个线程,共享一个进程的资源;

2.进程线程的区别:

   进程是资源分配的最小单位,线程是程序执行的最小单位

3.python中线程模块threading, 提供的类: thread, lock, rlock, semaphore, event, 等等

4.线程的创建方式

# 第一种
# from threading import thread
# def f1(s):
#     print('我是%s' % s)
# def f2(s):
#     print('我是%s' % s)
# 
# if __name__ == '__main__':
#     t = thread(target=f1, args=(1,))
#     t1 = thread(target=f1, args=(2,))
#     t.start()
#     t1.start()
#     print('我是主线程')

# 第二种
from threading import thread

class mythread(thread):
    def __init__(self, name):
        super().__init__()
        self.name = name
    def run(self):
        print('%s今天还是不能皮' % self.name)
if __name__ == '__main__':
    t = mythread('jerry')
    t.start()
    print('主线程')

6.查看线程的进程id(同进程查看方式一样)

import os
from threading import thread
def f1(n):
    print('1号', os.getpid())
    print('%s号线程任务' % n)
def f2(n):
    print('2号', os.getpid())
    print('%s号线程任务' % n)
if __name__ == '__main__':
    t1 = thread(target=f1, args=(1,))
    t2 = thread(target=f2, args=(2,))
    t1.start()
    t2.start()
    print('主线程', os.getpid())
    print('主线程')

7. 在进程之间数据是空间隔离的, 而在线程中是数据共享的

import time
from threading import thread

#  通过对全局变量的修改来验证线程之间是数据共享的, 共享同一进程中的数据
num = 100
def f1():
    time.sleep(3)
    global  num
    num = 3
    print('子线程的num', num)

if __name__ == '__main__':
    t = thread(target=f1)
    t.start()
    t.join() # 等待子线程运行结束才继续向下执行
    print('主线程的num', num)

python之线程相关操作

8.多进程和多线程的效率对比

对于io密集型的, 多线程的时间较快

def f1():
    time.sleep(1)  #io密集型
    
if __name__ == '__main__':
    # 查看一下20个线程执行20个任务的执行时间
    t_s_time = time.time()
    t_list = []
    for i in range(5):
        t = thread(target=f1,)
        t.start()
        t_list.append(t)
    [tt.join() for tt in t_list]
    t_e_time = time.time()
    t_dif_time = t_e_time - t_s_time
    # 查看一下20个进程执行同样的任务的执行时间
    p_s_time = time.time()
    p_list = []
    for i in range(5):
        p = process(target=f1,)
        p.start()
        p_list.append(p)
    [pp.join() for pp in p_list]
    p_e_time = time.time()
    p_dif_time = p_e_time - p_s_time
    print('多线程的执行时间:', t_dif_time)
    print('多jincheng的执行时间:', p_dif_time)

python之线程相关操作

计算型:

import time
from threading import thread
from multiprocessing import process

def f1():
    # 计算型:
    n = 10
    for i in range(10000000):
        n = n + i
if __name__ == '__main__':
    # 查看一下20个线程执行20个任务的执行时间
    t_s_time = time.time()
    t_list = []
    for i in range(5):
        t = thread(target=f1,)
        t.start()
        t_list.append(t)
    [tt.join() for tt in t_list]
    t_e_time = time.time()
    t_dif_time = t_e_time - t_s_time
    # 查看一下20个进程执行同样的任务的执行时间
    p_s_time = time.time()
    p_list = []
    for i in range(5):
        p = process(target=f1,)
        p.start()
        p_list.append(p)
    [pp.join() for pp in p_list]
    p_e_time = time.time()
    p_dif_time = p_e_time - p_s_time
    print('多线程的执行时间:', t_dif_time)
    print('多jincheng的执行时间:', p_dif_time)

python之线程相关操作

 

 9.锁,同步,互斥锁 为了保护多线成中数据的完整性和线程间状态的同步.(同进程的锁一样)

 在线程锁中, 会产生死锁现象. 同时抢锁

import time
from threading import thread, lock, rlock
def f1(loca, locb):
    # print('xxxx')
    # time.sleep(0.1)
    loca.acquire()
    print('f1>>1号抢到了a锁')

    time.sleep(1)
    locb.acquire()
    print('f1>>1号抢到了b锁')
    locb.release()

    loca.release()
def f2(loca, locb):
    print('22222')
    time.sleep(0.1)
    locb.acquire()
    print('f2>>2号抢到了b锁')
    loca.acquire()
    time.sleep(1)
    print('f2>>2号抢到了a锁')
    loca.release()
    locb.release()
if __name__ == '__main__':
    loca = lock()
    locb = lock()
    t1 = thread(target=f1, args=(loca, locb))
    t2 = thread(target=f2, args=(loca, locb))
    t1.start()
    t2.start()

  递归锁解决了 死锁现象

import time
from threading import thread, lock, rlock

def f1(loca, locb):
    print('xxxxx')
    time.sleep(0.1)
    loca.acquire()
    print('f1>>>1号抢到了a锁')
    time.sleep(1)
    locb.acquire()
    print('f1>>>2号抢到了b锁')
    locb.release()
    loca.release()
def f2(loca, locb):
    print('22222')
    time.sleep(0.1)
    locb.acquire()
    print('f2>>>1号抢到了a锁')
    time.sleep(1)
    loca.acquire()
    print('f2>>>2号抢到了b锁')
    loca.release()
    locb.release()
if __name__ == '__main__':
    loca = locb = rlock()
    t1 = thread(target=f1, args=(loca, locb))
    t2 = thread(target=f2, args=(locb, loca))
    t1.start()
    t2.start()

python之线程相关操作

10.多线程的程序不结束 和 多进程的程序不结束的区别

守护进程:主进程代码执行运行结束,守护进程随之结束
守护线程:守护线程会等待所有非守护线程运行结束才结束
import time
from threading import thread
from multiprocessing import process


# 守护进程:主进程代码执行运行结束,守护进程随之结束
# 守护线程:守护线程会等待所有非守护线程运行结束才结束
def f1():
    time.sleep(2)
    print('一号线程')

def f2():
    time.sleep(3)
    print('二号线程')
def f3():
    time.sleep(2)
    print('一号进程')

def f4():
    time.sleep(3)
    print('二号进程')
if __name__ == '__main__':
    # t1 = thread(target=f1,)
    # t2 = thread(target=f2,)
    # # t1.daemon = true  #  等非守护线程结束,守护线程才会结束 结果:  主线程结束  一号线程  二号线程
    # t2.daemon = true # 结果: 主线程结束      一号线程
    # t1.start()
    # t2.start()
    # print('主线程结束')
    p1 = process(target=f3,)
    p2 = process(target=f4,)
    # p1.daemon = true # 结果: 主进程   二号线程
    p2.daemon= true # 结果: 主进程   一号线程
    p1.start()
    p2.start()
    print('主进程')

11. gil锁 :  cpython解释器上的一把互斥锁, python解释器由于设计时有gil全局锁,导致了多线程无法利用多核

python虽然不能利用多线程实现多核任务,但可以通过多进程实现多核任务。多个python进程有各自独立的gil锁,互不影响。

python之线程相关操作