一、python線程的模塊

1.1 thread和threading模塊

thread模塊提供了基本的線程和鎖的支持

threading提供了更高級別、功能更強的線程管理的功能。

1.2 Queue模塊

Queue模塊允許用戶創建一個可以用于多個線程之間共享數據的隊列數據結構。

1.3注意模塊的選擇

• 避免使用thread模塊
• 因為更高級別的threading模塊更為先進，對線程的支持更為完善
• 而且使用thread模塊里的屬性有可能會與threading出現沖突；
• 其次低級別的thread模塊的同步原語很少(實際上只有一個)，而threading模塊則有很多；
• 再者，thread模塊中當主線程結束時，所有的線程都會被強制結束掉，沒有警告也不會有正常的清除工作，至少threading模塊能確保重要的子線程退出后進程才退出。

注意：thread模塊不支持守護線程，當主線程退出時，所有的子線程不論它們是否還在工作，都會被強行退出。而threading模塊支持守護線程，守護線程一般是一個等待客戶請求的服務器，如果沒有客戶提出請求它就在那等著，如果設定一個線程為守護線程，就表示這個線程是不重要的，在進程退出的時候，不用等待這個線程退出。

二、Threading模塊

multiprocess模塊的完全模仿了threading模塊的接口，二者在使用層面，有很大的相似性，因而不再詳細介紹（官方鏈接）

三、通過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.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
          

五、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('主線程')
          

六、多線程實現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'))
          

以上就是本文的全部內容，希望對大家的學習有所幫助，也希望大家多多支持腳本之家。