02网络编程多任务/多线程

一,什么是多任务

import  time
import  threading
#  Learner BM
"""

什么是多任务,因程序是自上而下的执行,当需要执行2个函数的时候,需要先执行完毕第一个函数,
然后再执行第二个函数,而多任务就是实现两个函数同时执行
并行: 真多任务,CPU数量执行
并发: 假多任务,CPU快速切换
主线程: 执行程序,执行完毕后,会等待子线程执行完毕后在执行
子线程: 主线程执下派生的子线程

多任务执行
    通过线程类,创建线程对象,目标为需要执行的函数
    t1 = threading.Thread(target= 函数名)
    t1对象的启动线程方法
    t1.start
"""
#  定义函数
def dance():
    for i in range(5):
        print('老板在跳舞')
        time.sleep(1)
#  定义函数
def sing():
    for i in range (5):
        print('老板在唱歌')
        time.sleep(1)
#  主函数
def mian():
    #****调用threading模块的thread类创建对象,(类的参数为 函数变量名)
    t1 = threading.Thread(target= dance)
    t2 = threading.Thread(target=dance)
    t1.start()
    t2.start()

if  __name__  == "__main__":
    mian()

二,o2_线程的特性.py

import  threading
import  time
#  Learner BM
""
"""
1,线程执行过程是没有顺序的,线程执行的时候是随机的,如果需要控制线程执行的顺序,需要对线程进行延时处理,
2,如果需要查看当前线程执行数量,可以使用enumerate函数
3,线程的创建与执行,从对象的start方法开始,一个函数的调用结束时,就是线程的生命周期结束完(创建线程对象的时候,不会创建线程)
4,子线程先结束后主线程在结束,否则程序出错
"""
#  定义函数

def dance():
    for i in range(5):
        print('老板在跳舞')
        time.sleep(1)
#  定义函数
def sing():
    for i in range (10):
        print('老板在唱歌')
        time.sleep(1)
#  主函数
def mian():
    #****调用threading模块的thread类创建对象,(类的参数为 函数变量名)
    t1 = threading.Thread(target= dance)
    t2 = threading.Thread(target=dance)
    t1.start()
    t2.start()
    #
    while True:
        print(threading.enumerate())
        if len(threading.enumerate())<=1:
            break
        time.sleep(1)

if  __name__  == "__main__":
    mian()

o3_线程的封装.py

#  Learner BM
import threading
import time
"""
创建线程有两种方法,一种是直接调用函数名,适合简单的线程调用
    t1 = threading.Thread(target=函数名)
另外一种是封装类进行,过程较为复杂,适合封装  较为复杂,函数较多的类
    1,封装一个类Mythread,继承threading.Thread类
        1.1 类内部必须定义run方法
            1.1.1 run方法内部代码
                  调用其他函数
    2,主程序执行,创建类的实例对象
        t1 = Mythread()
        t1.start()   #  strat会自动调用类内部的run方法,所以类里面必须定义run 

"""
#  封装线程类
class MyThread(threading.Thread):
    #  定义run方法
    def run(self):
        for i in range(5):
            print('run执行')
            time.sleep(1)
    def sing(self):
        for i in range(5):
            print('唱歌')
            time.sleep(1)

#  创建对象
t1 = MyThread()
t1.start()
t1.sing()

o4_线程之间共享全局变量.py

import  threading
"""

"""
"""
线程之间,使用的全局变量,是共享的,例如定义一个全局变量num=100,如果在线程1中对num进行修改为101
那么线程2访问num时候,num2的值同样是101,

############################################
复习,数据类型的可变不可变:

不可变类型:字符串,数字,元祖
可变类型,字典,列表

区别:

不可变类型
在函数        外部       定义全局变量
num=100
函数1内部对num进行修改
函数2访问num时值同样是100
################################

可变类型
在函数         外部       定义全局变量                     函数     内部            修改
list=[1,2,3]
函数1内部对list通过方法进行修改 list.append(4)             但是使用赋值语句进行修改时 list = [1,2,3,4]
函数2访问list时值同样是[1,2,3,4]                          函数2访问list时候,值会变成 [1,2,3,4]
################################


"""

#  不可变类型
#  定义不可变类型数据

#  全局变量
gl_num = 0
def test1(args):
    #  函数内部需要定义global
    global gl_num
    for i in range(args):

       gl_num+=10
    print('函数1修改不可变类型值为%s' % gl_num)

def test2(args):
    global gl_num
    for i in range(args):

        gl_num += 10
    print('函数2修改不可变类型值为%s' % gl_num)

t1 =threading.Thread(target= test1,args=(10000,))
t2 =threading.Thread(target= test2,args=(10000,))
print(gl_num)
t1.start()
t2.start()
"""
全局变量在线程之间会共享,容易产生资源竞争,同时修改时容易出现问题
"""

o5多进程udp聊天器.py

#  Learner BM
#  Learner BM
import socket
import  threading
"""

"""
"""
多线程版本
1 创建套接字
2,发送函数
3,接受函数

"""
    #  发送函数
def sendmsg(udp_socket):
    while True:
        senddata= input('请输入要发送的数据')
        udp_socket.sendto(senddata.encode('gbk'),('10.3.10.73',8080))
    # print('sendmsg')
    #  接收函数
def receivemsg(udp_socket):
    while True:
        #  接收消息,类型为元祖类型,(数据(ip,port))
        recv_data = udp_socket.recvfrom(1024)
        #  打印数据,元祖取值,进行解码为gbk
        print(recv_data[0].decode('gbk'))

def main():
    #  创建套接字
    udp_socket = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
    local_addr = ("10.3.10.73", 7880)
    udp_socket.bind(local_addr)
    #  创建线程,发送函数
    t_send =threading.Thread(target=sendmsg,args=(udp_socket,))
    #  创建线程,接收函数
    t_revice=threading.Thread(target=receivemsg,args=(udp_socket,))
    #  启动线程
    t_send.start()
    t_revice.start()
    #  关闭套接字,注意,关闭线程暂时无法使用?
    #udp_socket.close()
if __name__ == '__main__':
    main()

 

import  threading
import  time
#  Learner BM
""
"""
1,线程执行过程是没有顺序的,线程执行的时候是随机的,如果需要控制线程执行的顺序,需要对线程进行延时处理,
2,如果需要查看当前线程执行数量,可以使用enumerate函数
3,线程的创建与执行,从对象的start方法开始,一个函数的调用结束时,就是线程的生命周期结束完(创建线程对象的时候,不会创建线程)
4,子线程先结束后主线程在结束,否则程序出错
"""
#  定义函数

def dance():
for i in range(5):
print('老板在跳舞')
        time.sleep(1)
#  定义函数
def sing():
for i in range (10):
print('老板在唱歌')
        time.sleep(1)
#  主函数
def mian():
#****调用threading模块的thread类创建对象,(类的参数为 函数变量名)
t1 = threading.Thread(target= dance)
    t2 = threading.Thread(target=dance)
    t1.start()
    t2.start()
    #
while True:
print(threading.enumerate())
        if len(threading.enumerate())<=1:
break
time.sleep(1)

if  __name__  == "__main__":
mian()