# 没有多任务
# import time
#
# def sing():
# """唱歌5秒钟"""
# for i in range(5):
# print("---正在唱菊花台----")
# time.sleep(1)
#
# def dance():
# """跳舞5秒钟"""
# for i in range(5):
# print("---正在跳舞----")
# time.sleep(1)
#
# def main():
# sing()
# dance()
#
#
# if __name__=="__main__":
# main()
#使用多任务完成
# import time
# import threading
#
# def sing(): # ----子线程
# """唱歌5秒钟"""
# for i in range(5):
# print("---正在唱歌---")
# time.sleep(0.1)
#
#
# def dance(): # -----子线程
# """唱歌5秒钟"""
# for i in range(5):
# print("---正在跳舞---")
# time.sleep(0.1)
#
# def main():
# t1=threading.Thread(target=sing)
# t2=threading.Thread(target=dance) # 边唱歌边跳舞
# t1.start() #启动线程，让线程开始执行 ----主线程
# t2.start() #-----主线程
#
# if __name__=="__main__":
# main()
# 并行：真的多任务
# 并发：假的多任务
# 线程：一个程序运行起来之后，一定会有一个执行代码的东西，这个东西称为线程
# name3=["aa","bb","cc"]
# for temp in enumerate(name3): # 返回一个元组
# print(temp)
# 让某些线程先执行
# import threading
# import time
#
# def test1():
# for i in range(5):
# print("___test1___%d_"% i)
#
# def test2():
# for i in range(5):
# print("___test2___%d_"% i)
#
# def main():
# t1=threading.Thread(target=test1)
# t2=threading.Thread(target=test2)
#
# t1.start()
#
# time.sleep(1)
# print("______1________")
#
# t2.start()
# time.sleep(2)
# print("_______2_______")
#
# print(threading.enumerate())
# 线程的运行是没有先后顺序的----执行顺序不确定，----可以通过延时使其按顺序执行
# if __name__=="__main__":
# main()
# 循环查看当前运行的线程
# import threading
# import time
#
#
# def test1():
# for i in range(5):
# print("___test1___%d_"% i)
# time.sleep(1)
#
# # 如果创建Thread时执行的函数运行结束就意味着这个子线程结束了
#
# def test2():
# for i in range(10):
# print("___test2___%d_"% i)
# time.sleep(1)
#
# def main():
# t1=threading.Thread(target=test1)
# t2=threading.Thread(target=test2)
#
# t1.start() # 线程执行是通过start开始执行的，函数运行完就自动结束
# t2.start()
#
# while True:
# print(threading.enumerate())
# if len(threading.enumerate())<=1:
# break
# time.sleep(1)
#
#
# if __name__=="__main__":
# main()
# 验证创建线程以及运行时间
# import threading
# import time
#
#
# def test1():
# for i in range(5):
# print("___test1___%d_"% i)
# time.sleep(1)
#
#
# def main():
# # 在调用Thread之前打印当前线程信息
# print(threading.enumerate())
# t1=threading.Thread(target=test1)
#
# # 在调用Thread之后打印
# print(threading.enumerate())
#
# t1.start()
# # 在调用start之后打印
# print(threading.enumerate())
#
#
#
# if __name__=="__main__":
# main()
# 当调用Thread的时候，不会创建线程，
# 当调用Thread创建出来的实例对象的start方法的时候才会创建线程，以及让线程开始运行
# ) # 调用start方法间接调用run方法#通过继承Thread类完成线程
# import threading
# import time
#
#
# class MyThread(threading.Thread):
# def run(self):
# for i in range(3):
# time.sleep(1)
# print("I'm "+self.name+" @ "+str(i)) #name属性中保存的是当前线程的名字
# self.login()
# self.register()
#
# def login(self):
# print("这是登录---")
#
# def register(self):
# print("这是注册---")
#
# if __name__=="__main__":
# t=MyThread() # 创建一个Thread意味着将来只能调用一个线程
# t.start()
# 函数里面修改全局变量
# num=100
# def test():
# global num
# num+=1
# print(num) #100
# test()
# print(num) # 101
#
# nums=[11,22]
#
# def test2():
# nums.append(33)
# print(nums)
# test2()
# print(nums)
#在一个函数中对全局变及进行修改的时候，到底是否要使用global进行说明要看是否对全局变量的执行修改，
#如果修改了执行，即让全局变量执行一个新的地方，那么必须使用global；如果仅仅修改了执向空间中的数据，则不需要使用global
#多线程共享全局变量：子线程和子线程之间共享全局变量
# import threading
# import time
# # 定义一个全局变量
# g_num=100
#
# def test1():
# global g_num
# g_num+=1
# print("__in test1 g_=%d"% g_num)
#
# def test2():
# print("__in test2 g_num=%d"% g_num)
#
# def main():
# t1=threading.Thread(target=test1)
# t2=threading.Thread(target=test2)
# t1.start()
# time.sleep(1)
# t2.start()
# time.sleep(1)
#
# print("___in main Thred g_num=%d "%g_num)
#
#
#
# if __name__=="__main__":
# main()
# 验证多线程共享全局变量
import threading
import time
# 定义一个全局变量
# def test1(temp):
# temp.append(33)
# print("__in test1 temp=%s"% str(temp))
#
# def test2(temp):
# print("__in test2 temp=%s"% str(temp))
#
# g_nums=[11,22]
#
# def main():
# # target指定将来这个线程去那个函数执行代码
# # args指定将来调用函数的时候传递什么数据过去
# t1=threading.Thread(target=test1,args=(g_nums,))
# t2=threading.Thread(target=test2,args=(g_nums,))
# t1.start()
# time.sleep(1)
# t2.start()
# time.sleep(1)
#
# print("___in main Thred g_nums=%s "%str(g_nums))
#
#
#
# if __name__=="__main__":
# main()
# 共享全局变量的问题---资源竞争(出错)
# import threading
# import time
# 定义一个全局变量
# g_num=0
#
# def test1(num):
# global g_num
# for i in range(num):
# g_num+=1
# print("__in test1 g_=%d"% g_num)
#
# def test2(num):
# global g_num
# for i in range(num):
# g_num+=1
# print("__in test1 g_=%d"% g_num)
#
#
# def main():
# t1=threading.Thread(target=test1,args=(10000000,))
# t2=threading.Thread(target=test2,args=(100,))
# t1.start()
# t2.start()
# # 等待上边两个线程执行完毕
# time.sleep(5)
#
# print("___in main Thred g_num=%d "%g_num)
#
#
#
# if __name__=="__main__":
# main()
# 同步：就是协调同步，按照预先约定的顺序执行
# 互斥锁：解决资源竞争
# 创建锁
# mutex=threading.Lock()
# # 锁定
# mutex.acquire()
# #释放
# mutex.release()
#
# import threading
# import time
#
# g_num=0
#
# def test1(num):
# global g_num
# # 上锁，如果之前没有被上锁，那么此时上锁成功，
# # 如果上锁之前已经被上锁了，那么此时会堵塞在这里，直到这个锁被解开为止
# mutex.acquire()
# for i in range(num):
# g_num+=1
# # 解锁
# mutex.release()
# print("__in test1 g_=%d"% g_num)
#
# def test2(num):
# global g_num
# mutex.acquire()
# for i in range(num):
# g_num+=1
# mutex.release()
# print("__in test1 g_=%d"% g_num)
#
# # 创建一个互斥锁，默认是没有上锁的
# mutex=threading.Lock()
#
# def main():
# t1=threading.Thread(target=test1,args=(1000000,))
# t2=threading.Thread(target=test2,args=(1000000,))
# t1.start()
# t2.start()
# # 等待上边两个线程执行完毕
# time.sleep(5)
#
# print("___in main Thred g_num=%d "%g_num)
#
#
#
# if __name__=="__main__":
# main()
# 死锁：在线程间共享多个资源的时候，如果两个线程分别占有一部分资源并且同时等待对方的资源，就会造成死锁
# 避免死锁：1.程序设计尽量避免（银行家算法）2.添加超时时间
Processed:
0.009, SQL:
8
