31.线程对象与方法 互斥锁

""""""
"""
1.什么是线程
    进程线程其实都是虚拟单位,都是用来帮助我们形象的描述某种事物

    进程:资源单位
    线程:执行单位

        将内存比如成工厂
        那么进程就相当于是工厂里面的车间
        而你的线程就相当于是车间里面的流水线
    ps:每个进程都自带一个线程,线程才是真正的执行单位,进程只是在线程运行过程中
    提供代码运行所需要的资源


为什么要有线程
    开进程
        1.申请内存空间  耗资源
        2."拷贝代码"    耗资源

    开线程
        一个进程内可以起多个线程,并且线程与线程之间数据是共享的
    ps:开启线程的开销要远远小于开启进程的开销


"""

""""""
"""
创建线程方法一 直接实例化Thead,将要执行用target传入
"""
from threading import Thread
import time
import os


def test(name):
    print(f'{name} is running')
    print('son run')
    print(f'son:{os.getpid()},father:{os.getppid()}')
    print('son over')
    time.sleep(3)
    print(f'{name} is over')
"""
# if __name__ == '__main__':开线程不需要在__main__代码块内,但是习惯还是写在__main__代码下
"""
"""创建一个线程对象"""
t = Thread(target=test,args=('llx',))
print(os.getpid())
t.start() # # 告诉操作系统开辟一个线程  线程的开销远远小于进程
# 小的代码执行完 线程就已经开启了
print('主')
"""
25008
llx is running
son run
主
son:25008,father:2236
son over
llx is over

"""

""""""
"""
创建线程方法二 继承Thead类,覆盖run的方法,将任务放入run方法中
"""

from threading import Thread
import os
import time
class MyThread(Thread):

    def __init__(self,name):
        super().__init__()
        self.name = name
    def  run(self):
        print(f'{self.name} is running')
        print(f'son run:{os.getpid()}')
        time.sleep(3)
        print(f'father run :{os.getppid()}')
        print(f'{self.name} is over')

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

"""
llx is running
son run:18712
主
father run :2236
llx is over

"""

from threading import Thread,current_thread,active_count
import time
import os

def task(name,i):
    print(f'{name} is running')
    print(f'子current_thread:{current_thread().name}')
    print(f'子:{os.getpid()}')
    time.sleep(i)
    print(f'{name} is over')

t = Thread(target=task,args=('llx',1))
t1 = Thread(target=task,args=('llw',2))
t1.start() # # 告诉操作系统开辟一个线程  线程的开销远远小于进程
t.start()
t1.join() # # 主线程等待子线程运行完毕
t.join()
print(f'当前活跃的线程数{active_count()}')
# 小的代码执行完 线程就已经开启了
print('主')
print(f'主{current_thread().name}')
print(f'主:{os.getpid()}')

"""
llw is running
子current_thread:Thread-2
子:29904
llx is running
子current_thread:Thread-1
子:29904
llx is over
llw is over
当前活跃的线程数1
主
主MainThread
主:29904

"""

from threading import Thread,current_thread
import time
import os

def task(i):
    print(f'子线程名{current_thread().name}')
    time.sleep(i)
    print('GG')
t = Thread(target=task,args=(1,))
t1 = Thread(target=task,args=(2,))
t.daemon = True
t1.daemon = True
t.start()
t1.start()
print('主')
# 主线程运行结束之后需要等待子线程结束才能结束呢?
"""
主线程的结束也就意味着进程的结束
主线程必须等待其他非守护线程的结束才能结束
(意味子线程在运行的时候需要使用进程中的资源,而主线程一旦结束了资源也就销毁了)
"""
"""
守护前:
子线程名Thread-1
子线程名Thread-2
主
GG
GG

守护后:
子线程名Thread-1
子线程名Thread-2
主

"""

from threading import Thread

money = 666

def task():
    global money
    money = 6666666666666666

t = Thread(target=task)
t.start()
t.join()
print(money)
"""
6666666666666666
"""

from threading import Thread,Lock
import time

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(10):
    t = Thread(target=task,args=(mutex,))
    t.start()
    t_list.append(t)
for t in t_list:
    t.join()
    print(t)

print(n)

"""
<Thread(Thread-1, stopped 3784)>
<Thread(Thread-2, stopped 8892)>
<Thread(Thread-3, stopped 1340)>
<Thread(Thread-4, stopped 19772)>
<Thread(Thread-5, stopped 30900)>
<Thread(Thread-6, stopped 31688)>
<Thread(Thread-7, stopped 2772)>
<Thread(Thread-8, stopped 14044)>
<Thread(Thread-9, stopped 14168)>
<Thread(Thread-10, stopped 16860)>
90

"""