------------------------------方法不对,功力全废;做事讲方法,做人讲原则.
# # ------------------------------------------------------------------------------------------------------------#
''''
线程理论
线程是cpu的最小执行单位,进程:资源单位
线程的创建
From threading import Thread
T = Thread(target=func,args=())
Class MyThread(Thread):
Def __init__(self,n):
Super().__init()
Self.n = n
Def run(self):
Pass
T = MyThread(12)
线程和进程效率对比
Join方法
线程之间是数据共享的
同一进程中线程之间是数据共享的,全局变量验证了一下
锁(互斥锁\同步锁) #Lock,解决数据共享时数据不安全的问题,但是同时了牺牲了效率
死锁现象:双方互相等待对方释放对方手里拿到的那个锁
递归锁: Rlock 同样是互斥的.里面存着个计数器
守护线程:主线程等着进程中所有非守护线程的结束,才算结束
守护进程:主进程代码结束,守护进程跟着结束
信号量:大宝剑
事件: Event
'''
# # # --------------[线程的创建]--------------
#
# import time
# from threading import Thread
# from multiprocessing import Process
# #
# # def func(n):
# # print(n)
# #
# # if __name__ == '__main__':
# # # t = Thread(target=func,args=('我是线程',))
# # # t.start() #速度非常快
# # p = Process(target=func,args=('我是进程',))
# # p.start()
# # print('主线程结束')
#
# # class MyThread(Thread):
# #
# # def run(self):
# # print('sb明杰')
# #
# # if __name__ == '__main__':
# # t = MyThread()
# # t.start()
# # print('主线程结束')
#
#
# # # --------------[同一进程下线程是资源共享的]--------------
import time
from threading import Thread
from multiprocessing import Process
num = 100
def func():
global num
num = 0
if __name__ == '__main__':
t = Thread(target=func,)
t.start()
t.join()
print(num)
#
#
# # # --------------[线程的和进程的效率对比]--------------
#
# import time
# from threading import Thread
# from multiprocessing import Process
#
# def func(n):
# num = 0
# for n1 in range(n):
# num += n1
# print('num',num)
# if __name__ == '__main__':
# t_s_t = time.time()
# t_list = []
# for i in range(10):
# t = Thread(target=func,args=(10,))
# t.start() #速度非常快
# t_list.append(t)
# [tt.join() for tt in t_list]
# t_e_t = time.time()
# t_dif_t = t_e_t - t_s_t #获取了线程的执行时间
#
# p_s_t = time.time() #开始时间
# p_list = []
# for ii in range(10):
# p = Process(target=func,args=(10,))
# p.start()
# p_list.append(p)
# [pp.join() for pp in p_list]
# p_e_t = time.time() #结束时间
# p_dif_t = p_e_t - p_s_t #时间差
#
# print('线程>>>>',t_dif_t)
# print('进程....',p_dif_t)
# print('主线程结束')
#
#
## # --------------[验证线程间数据是否共享]--------------
import time
from threading import Thread,Lock
#演示共享资源的时候,数据不安全的问题
# num = 100
# def func():
# global num
# # num -= 1
# mid = num
# mid = mid - 1
# time.sleep(0.0001)
# num = mid
# if __name__ == '__main__':
#
# t_list = []
# for i in range(10):
# t = Thread(target=func,)
# t.start()
# t_list.append(t)
# [tt.join() for tt in t_list]
# print('主线程>>>',num)
## # --------------[通过锁来解决数据不安全]--------------
#的问题,线程模块里面引入的锁
# num = 100
# def func(t_lock):
# global num
# # num -= 1
# t_lock.acquire()
# mid = num
# mid = mid - 1
# time.sleep(0.0001)
# num = mid
# t_lock.release()
# if __name__ == '__main__':
# t_lock = Lock() #锁对象(同步锁,互斥锁)
# t_list = []
# for i in range(10):
# t = Thread(target=func,args=(t_lock,))
# t.start()
# t_list.append(t)
# [tt.join() for tt in t_list]
#
# print('主线程>>>',num)
## --------------[死锁现象]--------------
import time
from threading import Thread,Lock,RLock
def fuc1(locka,lockb):
locka.acquire()
print("+++++++++++++++a")
lockb.acquire()
print("+++++++++++++++b")
locka.release()
lockb.release()
def fuc2(locka, lockb):
lockb.acquire()
print("+++++++++++++++B")
locka.acquire()
print("+++++++++++++++A")
lockb.release()
locka.release()
if __name__ == '__main__':
# lock_A = Lock()
# lock_B = Lock()
lock_A = lock_B = RLock()
t1 = Thread(target=fuc1, args=(lock_A, lock_B))
t2 = Thread(target=fuc2, args=(lock_A, lock_B))
t1.start()
t2.start()
# # --------------[守护线程]--------------
#------主线程 会随着非守护线程的结束 而结束
import time
from threading import Thread
from multiprocessing import Process
def func1(n):
time.sleep(5)
print(n)
def func2(n):
time.sleep(3)
print(n)
if __name__ == '__main__':
# # --------------[复习回顾---守护进程]--------------
# ------主线程结束 守护进程也结束
#进程+守护进程示例#
p1 = Process(target=func1,args=('子进程1号',))
p1.daemon = True #设置守护,在start之前加
p1.start()
p2 = Process(target=func2, args=('子进程2号',))
# p2.daemon = True
p2.start()
# 线程+守护线程示例#
# t1 = Thread(target=func1, args=('子线程一号',))
# t1.daemon = True #设置守护,在start之前加
# t1.start()
# t2 = Thread(target=func2, args=('子线程二号',))
# t2.setdaemon(Ture)
# t2.start().
print('主进程结束!!')
# print('主线程结束')