线程

一：线程的基础概念#

（1）什么是线程：进程/线程其实都是虚拟单位 帮助我们描述某种事物

 

（2）线程进程的区别

　　（1）进程：

　　　　（1）资源单位

　　　　（2）其帮我提供程序运行所需要的资源

　　（2）线程：

　　　　（1）执行单位

　　　　（2）帮助我们真正的执行程序

例如：内存相当于一个工厂，程序就是工厂的车间，线程就是车间的流水线来执行车间的工作

PS：每一个进程都自带一个线程 进程提供程序运行所需要的资源 线程用来真正的执行程序

 

（3）线程的好处

　　开进程：

　　　　（1）开进程：申请内存空间 浪费资源

　　　　（2）代码拷贝：耗费资源

　　开线程：

　　　　（1）一个进程内可以开启多个线程

　　　　（2）线程之间数据是共享的

PS：使用线程的好处 节省内存资源

　

（3）线程的使用方法：

方法一：

from threading import Thread
import time


def test(name):
    print('%s running' % name)
    time.sleep(2)
    print('%s over' % name)


if __name__ == '__main__':
    t = Thread(target=test, args=('SR',))
    t.start()
    print('主')

方法二：

from threading import Thread
import time

class MyThread(Thread):
    def __init__(self,name):
        super().__init__()
        self.name = name

    def run(self):
        print('%s is running'%self.name)
        time.sleep(3)
        print('%s is over'%self.name)

t = MyThread('egon')
t.start()
print('主')

 

（3）线程之间的属性方法

import os
from threading import current_thread
def test():
    print(current_thread().name)
    print(os.getpid()) # 8248

t = Thread(target=test)
t.start()
print(current_thread().name)
print(os.getpid()) # 8248

PS:一个进程内可以有多个线程

 

from threading import active_count
def test():
    print('hello')

t = Thread(target=test)
t.start()
print(active_count())

 

（4）守护线程：

　　（1）主线程结束此时守护线程立马结束

　　（2）如果是非守护进程 如果主线程结束 其余子线程不会立马结束 需要等到所有子线程结束才能立马结束

因为：主线程结束立马主进程结束 其会回收资源空间  导致其余子线程不能再继续执行

 

（5）线程之间是可以相互通信的

from threading import Thread
money = 666
def test():
    global money
    money = 999

t = Thread(target=test)
t.start()
t.join()
print(money) # 999

 

（6）互斥锁

n = 100

def task(mutex):
    global  n
    mutex.acquire()
    tmp = n
    time.sleep(0.1)
    n = tmp - 1
    mutex.release()

t_list = []
mutex = Lock()
for i in range(100):
    t = Thread(target=task,args=(mutex,))
    t.start()
    t_list.append(t)
for t in t_list:
    t.join()
print(n)