线程

线程

 

线程理论

　　什么是线程?

　　　　进程其实是一个资源单位 真正被CPU执行的其实是进程里面的线程

 

　　　　进程类似于是工厂 线程类似于是工厂里面的一条条流水线

　　　　所有的进程肯定含有最少一个线程

 

　　　　进程间数据默认是隔离的 但是同一个进程内的多个线程数据是共享的

 

开设线程的两种方式

　　开设进程需要做哪些操作

　　　　1.重新申请一块内存空间

　　　　2.将所需的资源全部导入

　　开设线程需要做哪些操作

　　　　上述两个步骤都不需要 所以开设线程消耗的资源远比开设进程的少!!!

from threading import Thread
import time


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


t = Thread(target=test, args=('jason',))
t.start()
print('主')



class MyClass(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)

obj = MyClass('jason')
obj.start()
print('主线程')

 

线程对象的其他方法

　　1.join方法

　　2.获取进程号(验证同一个进程内可以开设多个线程)

　　3.active_count统计当前正在活跃的线程数

　　4.current_thread

 

守护线程

　　主线程的结束意味着整个进程的结束

　　　　所以主线程需要等待里面所有非守护线程的结束才能结束

from threading import Thread
from multiprocessing import Process
import time
def foo():
    print(123)
    time.sleep(3)
    print("end123")
def bar():
    print(456)
    time.sleep(1)
    print("end456")
if __name__ == '__main__':
    t1=Thread(target=foo)
    t2=Thread(target=bar)
    t1.daemon=True
    t1.start()
    t2.start()
    print("main-------")

 

 

线程数据共享

from threading import Thread
money = 100

def test():
    global money
    money = 999

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

 

线程互斥锁

from threading import Thread, Lock
from multiprocessing import Lock
import time


num = 100


def test(mutex):
    global num
    mutex.acquire()
    # 先获取num的数值
    tmp = num
    # 模拟延迟效果
    time.sleep(0.1)
    # 修改数值
    tmp -= 1
    num = tmp
    mutex.release()

t_list = []
mutex = Lock()
for i in range(100):
    t = Thread(target=test, args=(mutex,))
    t.start()
    t_list.append(t)
# 确保所有的子线程全部结束
for t in t_list:
    t.join()
print(num)