Python-并发编程之线程

线程

线程的特点：

1. 多个线程共享同一个进程的内存空间
2. 开启一个线程开销比进程小很多
3. 所有进程运行的最小单位就是线程

进程和线程的区别

1. 线程开启速度快
2. 同一个进程下的所有线程有相同的PID.
3. 同一个进程下的朵儿线程共享数据

开启线程的方式

开启线程的方式和开启进程的方式类似，可以通过自定义类或者导入模块的方式。

方式一

导入模块：

from threading import  Thread
import time
import random

def piao(name):
    print('%s is piaoing' %name)
    time.sleep(random.randint(1,3))
    print('%s is piao end' %name)

if __name__=='__main__':
    t1=Thread(target=piao,args=('bob',))

    t1.start()
    print('主')

输出：

bob is piaoing
主
bob is piao end

由于开启线程的开销小，所以线性会先执行。

方式二

通过自定义类：

from threading import Thread
import time
import random

class MyThread(Thread):
    def __init__(self,name):
        super().__init__()
        self.name=name

    def run(self):
        print('%s is piaoing' %self.name)
        time.sleep(random.randint(1,3))
        print('%s is piao end' %self.name)

if __name__=='__main__':
    t1=MyThread('bob')
    t1.start()
    print('主')

输出：

bob is piaoing
主
bob is piao end

多线程实现并发网络套接字通信

# 服务端

from socket import *
from threading import Thread,current_thread

def comunicate(conn):
    print('子线程: %s' %current_thread().getName())
    while True:
        try:
            data = conn.recv(1024)
            if not data: break
            conn.send(data.upper())
        except ConnectionResetError:
            break
    conn.close()

def server(ip,port):
    print('主线程：%s' %current_thread().getName())
    server = socket(AF_INET,SOCK_STREAM)
    server.bind((ip,port))
    server.listen(5)

    while True:
        conn,addr = server.accept()
        print(addr)

        t = Thread(target=comunicate,args=(conn,))
        t.start()
    server.close()

if __name__=='__main__':
    server('127.0.0.1',8080)
    

# 客户端

from socket import *

client=socket(AF_INET,SOCK_STREAM)
client.connect(('127.0.0.1',8080))

while True:
    msg = input('>>:').strip()
    if not msg: continue
    client.send(msg.encode('utf-8'))
    data=client.recv(1024)
    print(data.decode('utf-8'))
client.close()

    

守护线程

无论是进程还是线程，都遵循： 守护线程/进程会等待主线程/进程运行完毕后被销毁。

这里的运行完毕指的是：

1. 对主进程来说，运行完毕指的是主进程代码运行完毕。
2. 对主线程来说，运行完毕时主线程所在的进程内所有非守护线程都运行完毕，主线程才算运行完毕。

示例：

from threading import Thread
import time

def sayhi(name):
    print('子线程开启...')
    time.sleep(2)
    print('%s say hello' %name)

if __name__=='__main__':
    t=Thread(target=sayhi,args=('andy',))
    t.setDaemon(True)  # 等效 t.daemon=True
    t.start()

    print('主线程结束')

输出：

子线程开启...
主线程结束

设置为守护线程后，主线程结束子线程也会立即结束。

如下示例：

# coding=utf-8
import os
from threading import Thread
import time

def foo():
    print('这是守护线程')
    time.sleep(3)
    print('守护线程结束')

def bar():
    print('这是普通子线程')
    time.sleep(2)
    print('bar 运行结束')

if __name__ == '__main__':

    p1=Thread(target=foo)
    p2=Thread(target=bar)
    p1.daemon=True
    p1.start()
    p2.start()
    print("主线程到此结束！")

输出结果：

这是守护线程
这是普通子线程
主线程到此结束！
bar 运行结束