python-day33(线程)

一. 线程(threading模块)

　　线程是CPU的最小执行单位,进程: 资源单位

　　multiprocess模块完全模仿了threading模块的接口,二者在使用层面,有很大的相似性

import time
from threading import Thread
#多线程并发，是不是看着和多进程很类似
def func(n):
    time.sleep(1)
    print(n)

#并发效果，1秒打印出了所有的数字
for i in range(10):
    t = Thread(target=func,args=(i,))
    t.start()

　　1. 线程的创建

from threading import Thread
import time
def sayhi(name):
    time.sleep(2)
    print('%s say hello' %name)

if __name__ == '__main__':
    t=Thread(target=sayhi,args=('太白',))
    t.start()
    print('主线程')

import time
from threading import Thread
class Sayhi(Thread):
    def __init__(self,name):
        super().__init__()
        self.name=name
    def run(self):
        time.sleep(2)
        print('%s say hello' % self.name)


if __name__ == '__main__':
    t = Sayhi('太白')
    t.start()
    print('主线程')

　　2. 线程的方法

from threading import Thread
import time
def sayhi(name):
    time.sleep(2)
    print('%s say hello' %name)

if __name__ == '__main__':
    t=Thread(target=sayhi,args=('太白',))
    t2=Thread(target=sayhi,args=('alex',))
    t.start()
    t2.start()
    t.join()  #因为这个线程用了join方法，主线程等待子线程的运行结束

    print('主线程')
    print(t.is_alive())  #所以t这个线程肯定是执行结束了，结果为False
    print(t2.is_alive()) #有可能是True，有可能是False，看子线程和主线程谁执行的快
    '''
    egon say hello
    主线程
    False
    '''

Thread实例对象的方法
  # isAlive(): 返回线程是否活动的。
  # getName(): 返回线程名。
  # setName(): 设置线程名。

threading模块提供的一些方法：
  # threading.currentThread(): 返回当前的线程变量。
  # threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。
  # threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果


from threading import Thread
import threading
from multiprocessing import Process
import os

def work():
    import time
    time.sleep(3)
    print(threading.current_thread().getName())

if __name__ == '__main__':
    #在主进程下开启线程
    t=Thread(target=work)
    t.start()

    print(threading.current_thread())#主线程对象
    print(threading.current_thread().getName()) #主线程名称
    print(threading.current_thread().ident) #主线程ID
    print(threading.get_ident()) #主线程ID
    print(threading.enumerate()) #连同主线程在内有两个运行的线程
    print(threading.active_count())
    print('主线程/主进程')

    '''
    打印结果:
    <_MainThread(MainThread, started 14104)>
    MainThread
    14104
    14104
    [<_MainThread(MainThread, started 14104)>, <Thread(Thread-1, started 17976)>]
    2
    主线程/主进程
    Thread-1
    '''

二. 线程和进程效率对比

from threading import Thread
from multiprocessing import Process
import os
import time
def work():
    print('hello')

if __name__ == '__main__':
    s1 = time.time()
    #在主进程下开启线程
    t=Thread(target=work)
    t.start()
    t.join()
    t1 = time.time() - s1
    print('进程的执行时间：',t1)
    print('主线程/主进程')
    '''
    打印结果:
    hello
    进程的执行时间： 0.0
    主线程/主进程
    '''

    s2 = time.time()
    #在主进程下开启子进程
    t=Process(target=work)
    t.start()
    t.join()
    t2 = time.time() - s2
    print('线程的执行时间：', t2)
    print('主线程/主进程')
    '''
    打印结果:
    hello
    线程的执行时间： 0.5216977596282959
    主线程/主进程
    '''

三. 查看子线程和主线程是否在同一进程

# 查看子线程和主线程是否在同一个进程中
from threading import Thread
import os
def fun():
    print('子线程的pid',os.getpid()) #获得当前 线程pid
if __name__ == '__main__':
    t = Thread(target=fun,)
    t.start()
    print('主线程的pid',os.getpid()) #获得当前 pid  
#结果是一样的,是同一进程里

四. 线程之间的数据是共享的

from threading import Thread
def fun():
    global a
    a -= 1
a = 10
if __name__ == '__main__':

    t = Thread(target=fun,)
    t.start()
    t.join() # 加join 等待t 结束
    print(a) # 9 证明数据是共享的

五. 验证多线程共享资源造成的数据不安全

# 验证多线程共享资源造成的数据不安全的问题
from threading import Thread
import time
def fun():
    global a
    t = a
    time.sleep(0.00001)
    t -= 1
    a = t
a = 20
if __name__ == '__main__':
    l = []
    for i in range(20):
        t = Thread(target=fun,)
        l.append(t)
        t.start()
    for i in l :
        i.join()
    print(a) # 18 

六. 加锁解决共享数据不安全的问题

　　锁(互斥锁同步锁) #Lock,解决数据共享是数据不安全的问题,

　　　　　　但同时也牺牲了效率

　　

 

from threading import Thread,Lock
import time
def fun(l):
    l.acquire()
    global a
    t = a
    time.sleep(0.1)
    t -= 1
    a = t
    l.release()
a = 20
if __name__ == '__main__':
    l = []
    lock = Lock()
    for i in range(20):
        t = Thread(target=fun ,args=(lock,))
        l.append(t)
        t.start()
    for i in l:
        i.join()
    print(a)

七. 死锁现象

　　死锁现象: 双方互相等待对方释放对方手里拿到的那个锁

　　

from threading import Thread ,Lock
import time

def fun1(lock_A,lock_B):
    lock_A.acquire()
    time.sleep(1)

    print('A抢到了锁a')
    lock_B.acquire()
    print('A抢到了锁b')
    lock_B.release()
    lock_A.release()
def fun2(lock_A,lock_B):
    lock_B.acquire()
    print('B抢到了b锁')
    lock_A.acquire()
    print('B抢到了a锁')
    lock_A.release()
    lock_B.release()
if __name__ == '__main__':
    lock_A = Lock()
    lock_B = Lock()
    t1 = Thread(target=fun1,args=(lock_A,lock_B))
    t2 = Thread(target=fun2,args=(lock_A,lock_B))
    t1.start()
    t2.start()

八. 解决死锁, 使用递归锁

　　同样是互斥,里面存着个计数器

　　进程的死锁和线程的是一样的,而且一般情况下进程之间是数据不共享的,

不需要加锁,由于线程是对全局的数据共享的,所以对于全局的数据进行操作的时候,要加锁.

import time
from threading import Thread,RLock
fork_lock = noodle_lock = RLock()
def eat1(name):
    noodle_lock.acquire()
    print('%s 抢到了面条'%name)
    fork_lock.acquire()
    print('%s 抢到了叉子'%name)
    print('%s 吃面'%name)
    fork_lock.release()
    noodle_lock.release()

def eat2(name):
    fork_lock.acquire()
    print('%s 抢到了叉子' % name)
    time.sleep(1) 
    noodle_lock.acquire()
    print('%s 抢到了面条' % name)
    print('%s 吃面' % name)
    noodle_lock.release()
    fork_lock.release()

for name in ['taibai','wulaoban']:
    t1 = Thread(target=eat1,args=(name,))
    t1.start()
for name in ['alex','peiqi']:
    t2 = Thread(target=eat2,args=(name,))
    t2.start()

九. 守护线程

　　守护线程: 主线程等着进程中所有非守护线程的结束,才算结束

　　守护进程: 主进程代码结束, 守护进程跟着结束

# 守护线程
from threading import Thread
import time
from multiprocessing import Process

def fun1():
    time.sleep(3)
    print(111111111111)
def fun2():
    time.sleep(2)
    print(222222222222)
if __name__ == '__main__':
    # p1 = Process(target=fun1, )
    # p2 = Process(target=fun2, )
    # p2.daemon = True
    # # p1.daemon = True
    # p1.start()
    # p2.start()

    t1 = Thread(target=fun1,)
    t2 = Thread(target=fun2,)
    t2.daemon = True
    # t1.daemon = True
    t1.start()
    t2.start()


    print('结束')

十. 信号量

# 信号量
import time,random
from multiprocessing import Process,Semaphore
from threading import Thread,Semaphore
def fun(i,s):
    s.acquire()
    time.sleep(random.randint(1,3))
    print('%s号来了' %i)
    s.release()

if __name__ == '__main__':
    s = Semaphore(4)
    for i in range(10):
        t = Thread(target=fun,args=(i,s)) # 线程守护
        t.start()

    # s = Semaphore(4)    
    # for i in range(10):
    #     p = Process(target=fun,args=(i,s))   #进程守护
    #     p.start()

十一. 事件

from threading import Thread,Event
e = Event() #默认状态False
print(1)
e.set() #设置状态为True
print(e.is_set()) #查看状态
e.clear() # 设置状态 False
print(e.is_set()) #查看状态
e.set()  #设置状态
print(e.is_set()) #查看状态
e.wait() #判断 等 False  走True
print('结束')