线程基础
# 线程基础
"""
多任务的概念：就是操作系统可以同时运行多个任务
并发：指的是任务数多余cpu核数，通过操作系统的各种任务调度算法，实现用多个任务“一起”执行（实际上总有一些任务不在执行，因为切换任务的速度相当快，看上去一起执行而已）
并行：指的是任务数小于等于cpu核数，即任务真的是一起执行的
python的thread模块是比较底层的模块，python的threading是高级模块
常用操作
threading.currentThread(): 返回当前的线程变量。
threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程
threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果
run(): 用以表示线程活动的方法
start():启动线程活动
join([time]): 等待至线程中止。这阻塞调用线程直至线程的join() 方法被调用中止-正常退出或者抛出未处理的异常-或者是可选的超时发生
isAlive(): 返回线程是否活动的
getName(): 返回线程名
setName(): 设置线程名
线程注意点
使用threading模块时，往往会定义一个新的子类class，只要继承threading.Thread就可以了，然后重写run方法
当线程的run()方法结束时该线程完成。
多线程程序的执行顺序是不确定的 无法控制线程调度程序，但可以通过别的方式来影响线程调度的方式。
每个线程默认有一个名字，python会自动为线程指定一个名字
在一个进程内的所有线程共享全局变量，很方便在多个线程间共享数据
线程是对全局变量随意遂改可能造成多线程之间对全局变量的混乱（即线程非安全）
如果多个线程同时对同一个全局变量操作，会出现资源竞争问题，从而数据结果会不正确
同步就是协同步调，按预定的先后次序进行运行。如:你说完，我再说。
可理解为进程或线程A和B一块配合，A执行到一定程度时要依靠B的某个结果，于是停下来，示意B运行;B执行，再将结果给A;A再继续操作。
线程同步
当多个线程几乎同时修改某一个共享数据的时候，需要进行同步控制
使用 Thread 对象的 Lock 和 Rlock 可以实现简单的线程同步，这两个对象都有 acquire 方法和 release 方法
对于那些需要每次只允许一个线程操作的数据，可以将其操作放到 acquire 和 release 方法之间
线程同步能够保证多个线程安全访问竞争资源，最简单的同步机制是引入互斥锁
某个线程要更改共享数据时，先将其锁定，此时资源的状态为“锁定”，其他线程不能更改；
直到该线程释放资源，将资源的状态变成“非锁定”，其他的线程才能再次锁定该资源。
互斥锁保证了每次只有一个线程进行写入操作，从而保证了多线程情况下数据的正确性。
hreading模块中定义了Lock类，可以方便的处理锁定
# 创建锁
mutex = threading.Lock()
# 锁定
mutex.acquire()
# 释放
mutex.release()
锁的好处 确保了某段关键代码只能由一个线程从头到尾完整地执行
锁的坏处 阻止了多线程并发执行 可能会造成死锁
死锁
在线程间共享多个资源的时候，如果两个线程分别占有一部分资源并且同时等待对方的资源，就会造成死锁
避免死锁
程序设计时要尽量避免（银行家算法）
添加超时时间等
"""
# 多线程创建方式一
import threading
# threading.Thread(target=函数) 传名称即可
def say():
print("你好啊，python")
for i in range(5):
t = threading.Thread(target=say)
t.start() # 当调用start()时，才会真正的创建线程，并且开始执行
# 主线程会等待所有的子线程结束后才结束
import threading
from time import sleep,ctime
def sing():
for i in range(3):
print("正在唱歌...%d" % i)
sleep(1)
def dance():
for i in range(3):
print("正在跳舞...%d" % i)
sleep(1)
if __name__ == '__main__':
print('---开始---:%s' % ctime())
t1 = threading.Thread(target=sing)
t2 = threading.Thread(target=dance)
t1.start()
t2.start()
sleep(5) # 屏蔽此行代码，试试看，程序是否会立马结束？
print('---结束---:%s' % ctime())
# 查看线程数量
import threading
from time import sleep,ctime
def sing():
for i in range(3):
print("正在唱歌...%d" % i)
sleep(1)
def dance():
for i in range(3):
print("正在跳舞...%d" % i)
sleep(1)
if __name__ == '__main__':
print('---开始---:%s' % ctime())
t1 = threading.Thread(target=sing)
t2 = threading.Thread(target=dance)
t1.start()
t2.start()
alength = threading.activeCount()
print("活动线程数量是:%s" % alength)
while True:
# length = len(threading.enumerate()) # 返回一个包含正在运行的线程的list列表
# print('运行的线程数为：%d' % length)
# if length <= 1:
# break
alength = threading.activeCount()
print("活动线程数量是:%s" % alength) # 返回正在运行的线程数量 threading.activeCount() == len(threading.enumerate())
if alength <= 1:
break
sleep(0.5)
# 线程的执行顺序 不能确定
import threading
import time
class MyThread(threading.Thread):
def run(self):
for i in range(3):
time.sleep(1)
msg = "I'm "+self.name+' @ '+str(i)
print(msg)
def test():
for i in range(5):
t = MyThread()
t.start()
if __name__ == '__main__':
test()
# 线程执行代码的封装
import threading
import time
class MysThread(threading.Thread):
def run(self):
for i in range(3):
time.sleep(1)
msg = "I'm "+self.name+' @ '+str(i) # name属性中保存的是当前线程的名字
print(msg)
if __name__ == '__main__':
t = MysThread()
t.start()
# 多线程数据是共享的
from threading import Thread
import time
g_num = 100
def work1():
global g_num
for i in range(3):
g_num += 1
print("----in work1, g_num is %d---"%g_num)
def work2():
global g_num
print("----in work2, g_num is %d---"%g_num)
print("---线程创建之前g_num is %d---"%g_num)
t1 = Thread(target=work1)
t1.start()
# 延时一会，保证t1线程中的事情做完
time.sleep(1)
t2 = Thread(target=work2)
t2.start()
# 互斥锁 -- 解决数据共享出现的问题
import threading
import time
g_num = 0
def test1(num):
global g_num
for i in range(num):
mutex.acquire() # 上锁
g_num += 1
mutex.release() # 解锁
print("---test1---g_num=%d"%g_num)
def test2(num):
global g_num
for i in range(num):
mutex.acquire() # 上锁
g_num += 1
mutex.release() # 解锁
print("---test2---g_num=%d"%g_num)
# 创建一个互斥锁
# 默认是未上锁的状态
mutex = threading.Lock()
# 创建2个线程，让他们各自对g_num加1000000次
p1 = threading.Thread(target=test1, args=(1000000,))
p1.start()
p2 = threading.Thread(target=test2, args=(1000000,))
p2.start()
# 等待计算完成
while len(threading.enumerate()) != 1:
time.sleep(1)
print("2个线程对同一个全局变量操作之后的最终结果是:%s" % g_num)
# udp 聊天
import socket
import threading
# 接收信息
def recvs(udp_socket):
while True:
back = udp_socket.recvfrom(1024)
msg = back
print(msg)
# 发送信息
def sends(udp_socket, dest_ip, dest_port):
while True:
msg = input("请输入你要发送的信息:")
if msg == 'exit':
break
udp_socket.sendto(msg.encode(), (dest_ip, dest_port))
# udp主函数
def main():
udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
udp_socket.bind(('', 8001))
dest_ip = input("请输入对方的ip:")
dest_port = int(input("请输入对方的port:"))
t1 = threading.Thread(target=sends, args=(udp_socket, dest_ip, dest_port))
t2 = threading.Thread(target=recvs, args=(udp_socket,))
t1.start()
t2.start()
if __name__ == '__main__':
main()
