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'))