python多线程

1.线程理论

1 什么是线程
    进程其实一个资源单位,而进程内的线程才是cpu上的执行单位
    线程其实指的就是代码的执行过程
　　 线程之间本质没有父子关系
　　　　
2 为何要用线程
    线程vs进程
        1. 同一进程下的多个线程共享该进程内的资源
        2. 创建线程的开销要远远小于进程
x=1
y=2
print('===>',x,y)
右键一运行,是开了一个进程,是开辟了一个内存空间,将python解释器以及python代码丢进去.
线程相当于代码的运行(资源已经全部准备好)

2.开启线程的两种方式
方式1:

from threading import Thread
import time

def task(name):
    print('%s is running' %name)
    time.sleep(2)
    print('%s is done' %name)

if __name__ == '__main__':
    t=Thread(target=task,args=('线程1',))
    t.start()
    print('主')
方式2:

from threading import Thread
import time

class Mythread(Thread):
    def run(self):
        print('%s is running' %self.name)
        time.sleep(2)
        print('%s is done' %self.name)

if __name__ == '__main__':
    t=Mythread()
    t.start()
    print('主')

3.线程的特性介绍:

from threading import Thread

n=100
def task():
    global n
    n=0

if __name__ == '__main__':
    t=Thread(target=task)
    t.start()
    t.join()
    print('主',n)
结果:n=0
证明线程之间共享内存

from threading import Thread
import time,os

def task():
    print('%s is running' %os.getpid())

if __name__ == '__main__':
    t=Thread(target=task)
    t.start()
    print('主',os.getpid())
结果:
12328 is running
主 12328
pid号相同,说明这两个线程同属于一个进程

from threading import Thread,active_count
import time

def task(name):
    print('%s is running' %name)
    time.sleep(2)

if __name__ == '__main__':
    t=Thread(target=task,args=('aa',))
    t.start()
    print('主',active_count())
结果:
aa is running
主 2
active_count:统计活跃的线程个数

from threading import Thread,current_thread
import time

def task():
    print('%s is running' %current_thread().name)
    time.sleep(2)

if __name__ == '__main__':
    t=Thread(target=task,)
    t.start()
    print('主',current_thread().name)
结果:
Thread-1 is running
主 MainThread

3.守护线程
主线程应该等着所有非守护线程运行完毕之后再结束,当主线程一结束,守护线程也会跟着结束

from threading import Thread
import time
def foo():
    print(123)
    time.sleep(1)
    print("end123")

def bar():
    print(456)
    time.sleep(3)
    print("end456")


t1=Thread(target=foo)
t2=Thread(target=bar)

t1.daemon=True
t1.start()
t2.start()
print("main-------")

输出结果:
123
456
main-------
end123
end456

4.线程的互斥锁:

from threading import Thread
import time

n=100
def task():
    global n
    temp=n
    time.sleep(0.1)
    n=temp-1

if __name__ == '__main__':
    t_l=[]
    for i in range(100):
        t=Thread(target=task)
        t_l.append(t)
        t.start()

    for t in t_l:
        t.join()
    print(n)
结果:
99(结果会瞬间打印出来)
因为所有的线程都会休眠0.1秒,所以所有的线程拿到的temp都是100,执行-1操作之后为99

from threading import Thread,Lock
import time

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

if __name__ == '__main__':
    t_l=[]
    for i in range(100):
        t=Thread(target=task)
        t_l.append(t)
        t.start()

    for t in t_l:
        t.join()
    print(n)
结果:
0(大概会经过10秒才会打印出结果)
因为当第一个线程会加锁,将temp-1,解锁之后,后面的线程拿到的temp都是经过前面线程处理过的