118 python程序中的线程操做-建立多线程

1、python线程的模块

1.1 thread和threading模块

• thread模块提供了基本的线程和锁的支持
• threading提供了更高级别、功能更强的线程管理的功能。

1.2 Queue模块

• Queue模块容许用户建立一个能够用于多个线程之间共享数据的队列数据结构。

1.3注意模块的选择

1. 避免使用thread模块
2. 由于更高级别的threading模块更为先进，对线程的支持更为完善
3. 并且使用thread模块里的属性有可能会与threading出现冲突；
4. 其次低级别的thread模块的同步原语不多(实际上只有一个)，而threading模块则有不少；
5. 再者，thread模块中当主线程结束时，全部的线程都会被强制结束掉，没有警告也不会有正常的清除工做，至少threading模块能确保重要的子线程退出后进程才退出。

注意：thread模块不支持守护线程，当主线程退出时，全部的子线程不论它们是否还在工做，都会被强行退出。而threading模块支持守护线程，守护线程通常是一个等待客户请求的服务器，若是没有客户提出请求它就在那等着，若是设定一个线程为守护线程，就表示这个线程是不重要的，在进程退出的时候，不用等待这个线程退出。

2、Threading模块

multiprocess模块的彻底模仿了threading模块的接口，两者在使用层面，有很大的类似性，于是再也不详细介绍（官方连接）

3、经过Threading.Thread类来建立线程

3.1 建立线程的方式一

1.直接经过Threading.Thread来建立
from threading import Thread
import time

def task(name):
    print(f'子线程{name} is running')
    time.sleep(1)
    print(f'子线程{name} is end')
    
# 由于建立线程不须要从新开辟内存空间，因此不用写main，建立线程只是单独把启动线程函数里面的代码拿出来用
t = Thread(target=task,args=('Cecilia陈',))
t.start()
print('主线程结束')

子线程Cecilia陈 is running

主线程结束

子线程Cecilia is end

3.2 建立线程的方式二

2.经过自定义类来继承Thread类来建立线程
from threading import Thread
import time

class MyDic(Thread,name):
    def __init__(self,name)
        super().__init__()
        self.name = name
    
    def run(self):
        print(f'子线程{name} is running')
        time.sleep(1)
        print(f'子线程{name} is end')

       
t = Mydic('Cecilia陈')
t.start()
print('主进程结束')

线程Cecilia陈 start
主进程
线程Cecilia陈 end

4、多线程和多进程的比较

4.1 pid的比较

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

def task(name):
    print(f'子线程{name} is running')
    time.sleep(1)
    print(f'子线程{name} is end')
    print(f'子线程{name}的pid：{os.getpid()}')


def task1(name):
    print(f'进程{name} is running')
    time.sleep(1)
    print(f'进程{name} is end')
    print(f'进程的{name}pid：{os.getpid()}')


if __name__ == '__main__':
    # part1:在主进程下开启多个线程,每一个线程都跟主进程的pid同样
    t = Thread(target=task, args=('Cecilia陈',))
    t.start()
    t.join()
    print(f'主线程的pid：{os.getpid()}')

    
    # 开多个进程，每个进程的pid号都不同
    p = Process(target=task1,args=('xichen',))
    p1 = Process(target=task1,args=('xixi',))
    p.start()
    p1.start()
    p.join()
    p1.join()
    print(f'主进程的pid：{os.getpid()}')

子线程Cecilia陈 is running
子线程Cecilia陈 is end
子线程Cecilia陈的pid：10892
主线程的pid：10892
进程xixi is running
进程xichen is running
进程xichen is end
进程xixi is end
进程的xichenpid：6844
进程的xixipid：13700
主进程的pid：10892

4.2 线程和进程开启效率的较量

from threading import Thread
from multiprocessing import Process
import time

def task(name):
    print(f'{name} is running')
    time.sleep(2)
    print(f'{name} is end')


if __name__ == '__main__':
    t = Thread(target=task,args=('子线程',))
    p = Process(target=task,args=('子进程',))
    t.start()
    # p.start()
    print('主')

1.开启线程的速度:

子线程 is running

主

子线程 is end

2.开启进程的速度：

主

子进程 is running

子进程 is end

4.3 内存数据共享问题

from threading  import Thread
from multiprocessing import  Process
import time,os

x = 100
def task():
    global x
    x = 50 # 此时线程是在拿全局的x的值
    print(os.getpid()) # 由于开启线程是不须要操做系统给线程分配内存空间的，因此线程用的是它当前所在的进程的进程号


if __name__ == '__main__':
    # 线程
    t = Thread(target=task)
    t.start()
    time.sleep(2)
    print(x) # 50，这里说明线程他是共享他所在进程下的全部资源，对资源进行一系列的操做
    print(os.getpid())

    # 进程
   # p = Process(target=task)
   # p.start() 
   # print(x) # 这里的x仍是主进程的x 100

5、Thread类的其余方法

Thread实例对象的方法：

• isAlive()：返回线程是否活动的。
• getName()：返回线程名。
• setName()：设置线程名。

threading模块提供的一些方法：

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

5.1 代码实例

from threading import Thread,currentThread,enumerate,activeCount
import time

def task():
    print('子线程 start')
    time.sleep(2)
    print('子线程 end')
    print(enumerate())# 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。
    print(currentThread(),'子线程') # 返回当前的线程变量
    print(activeCount())

if __name__ == '__main__':
   t1 = Thread(target=task)
   t2 = Thread(target=task)
   t1.start()
   t2.start()
   t2.setName('Cecilia陈')
   print(t2.getName()) # 获得t2的线程名字，是咱们设置好的Cecilia陈
   print(t1.getName()) # 获得t1的线程名子 Thread-1
   print(t1.is_alive()) # True

5.2 join方法

from threading import Thread
import time
def task():
    print('子线程 start')
    time.sleep(2)
    print('子线程 end')

t = Thread(target=task)
t.start()
t.join() # 等待子线程运行结束
print('主线程')

6、多线程实现socket

6.1 服务端

import socket
from threading import Thread

socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
socket.bind(('192.168.11.78',8004))
socket.listen(5)

def action(conn,addr):
    while True:
        try:

            msg = (conn.recv(1024)).decode('utf8').upper()
            print(f'客户端{addr}发送的数据为：{msg.lower()}')
            print(f'向客户端{addr}发送数据为',msg)
            conn.send(msg.encode('utf8'))
        except:
            break


if __name__ == '__main__':
    print('等待客户端链接:')
    while True:
        try:
            conn,addr = socket.accept()
            print(f'客户端已链接{addr}')
            t = Thread(target=action,args=(conn,addr))
            t.start()
        except:
            print(f'客户端{addr}断开链接 ！！')
            break

6.2 客户端

import  socket

client = socket.socket()
client.connect(('192.168.11.78',8004))

while True:
    msg = input('输入：')
    if msg == 'q':
        break
    client.send(msg.encode('utf8'))
    flag = client.recv(1024)
    print('接收服务端的数据为：',flag.decode('utf8'))