Membawa anda untuk mentafsir Python multi-threading

Artikel ini membawakan anda pengetahuan yang berkaitan tentang python, yang terutamanya memperkenalkan pengetahuan yang berkaitan tentang multi-threading adalah serupa dengan melaksanakan berbilang program yang berbeza pada masa yang sama dan mempunyai banyak kelebihan, mari lihat di bawah, semoga bermanfaat untuk semua.

Pembelajaran yang disyorkan: tutorial python

Penjelasan threading

Multi-threading adalah serupa dengan melaksanakan berbilang program berbeza pada masa yang sama , operasi berbilang benang mempunyai kelebihan berikut:

• Menggunakan benang boleh meletakkan tugas program jangka panjang ke latar belakang untuk diproses.
• Antara muka pengguna boleh menjadi lebih menarik, jadi jika pengguna mengklik butang untuk mencetuskan pemprosesan acara tertentu, bar kemajuan boleh muncul untuk menunjukkan kemajuan pemprosesan.
• Program mungkin berjalan lebih pantas.
• Benang lebih berguna dalam melaksanakan beberapa tugas menunggu seperti input pengguna, membaca dan menulis fail serta menghantar dan menerima data rangkaian. Dalam kes ini kita boleh mengeluarkan beberapa sumber berharga seperti penggunaan memori dan sebagainya.

  Masih terdapat perbezaan antara benang dan proses semasa pelaksanaan. Setiap urutan bebas mempunyai titik masuk untuk pelaksanaan program, urutan pelaksanaan berurutan dan titik keluar untuk program. Walau bagaimanapun, benang tidak boleh dilaksanakan secara bebas dan mesti wujud dalam program aplikasi, dan program aplikasi menyediakan kawalan pelaksanaan berbilang benang.
 Setiap utas mempunyai set daftar CPU sendiri, dipanggil konteks utas, yang mencerminkan keadaan CPU mendaftar utas terakhir dijalankan.
 Penunjuk arahan dan Daftar penuding tindanan ialah dua daftar paling penting dalam konteks utas Arahan ini sentiasa dijalankan dalam konteks proses Memori dalam ruang alamat proses benang.
 Benang boleh didahulukan (terganggu).
 Benang boleh ditangguhkan buat sementara waktu (juga dipanggil tidur) semasa utas lain sedang berjalan – ini dipanggil pengunduran benang.
Benang boleh dibahagikan kepada:

• Benang kernel: dicipta dan dibatalkan oleh kernel sistem pengendalian.
• Urutan pengguna: Urutan yang dilaksanakan dalam program pengguna tanpa sokongan kernel.

Dua modul yang biasa digunakan dalam utas Python3 ialah:

• _thread
• benang (disyorkan)

Modul utas telah ditamatkan. Pengguna boleh menggunakan modul threading sebaliknya. Oleh itu, modul "benang" tidak lagi boleh digunakan dalam Python3. Untuk keserasian, Python3 menamakan semula thread kepada "_thread".

Mula belajar benang Python

  Terdapat dua cara untuk menggunakan benang dalam Python: fungsi atau kelas untuk membungkus objek benang.
Berfungsi: Panggil fungsi start_new_thread() dalam modul _thread untuk menjana urutan baharu. Sintaks adalah seperti berikut:

_thread.start_new_thread ( function, args[, kwargs] )

  Perihalan parameter:

• fungsi - fungsi benang.
• args - parameter yang dihantar ke fungsi benang, ia mestilah jenis tuple.
• kwarg - parameter pilihan.

  Contoh:

#!/usr/bin/python3

import _thread
import time

# 为线程定义一个函数
def print_time( threadName, delay):
    count = 0
    while count <p>  Output melaksanakan program di atas adalah seperti berikut: <br><img src="https://img.php.cn/upload/article/000/000/067/9e54370fdafb34f8739135c680e1aa53-0.png" alt="Membawa anda untuk mentafsir Python multi-threading"></p><h2> Modul threading </h2><p> Python3 lulus dua Pustaka standard _thread dan threading menyediakan sokongan untuk thread. </p>

• _benang menyediakan benang primitif tahap rendah dan kunci ringkas Fungsinya agak terhad berbanding dengan modul benang.
• Selain semua kaedah dalam modul _thread, modul threading juga menyediakan kaedah lain:
• threading.currentThread(): Mengembalikan pembolehubah thread semasa.
• threading.enumerate():
  Mengembalikan senarai yang mengandungi benang yang sedang berjalan. Running merujuk kepada thread selepas ia bermula dan sebelum ia tamat, tidak termasuk thread sebelum permulaan dan selepas penamatan.
• threading.activeCount():
  Mengembalikan bilangan thread yang sedang berjalan, yang mempunyai hasil yang sama seperti len(threading.enumerate()).

  Selain kaedah penggunaan, modul thread juga menyediakan kelas Thread untuk mengendalikan thread. Kelas Thread menyediakan kaedah berikut:

• run(): digunakan untuk. mewakili kaedah aktiviti benang.
• start(): Mulakan aktiviti thread.
• sertai([masa]): Tunggu sehingga urutan ditamatkan. Ini menyekat utas panggilan sehingga kaedah join()
  utas dipanggil dan dibatalkan - keluar seperti biasa atau membuang pengecualian yang tidak dikendalikan - atau tamat masa pilihan berlaku.
• isAlive(): Mengembalikan sama ada urutan itu aktif.
• getName(): Mengembalikan nama utas.
• setName(): Tetapkan nama utas.

Gunakan modul threading untuk mencipta thread

Kita boleh mencipta subclass baharu dengan mewarisi terus daripada threading. Thread, dan panggil kaedah start() untuk memulakan thread baharu selepas instantiasi , iaitu Ia memanggil kaedah run() benang:

#!/usr/bin/python3

import threading
import time

exitFlag = 0

class myThread (threading.Thread):
    def __init__(self, threadID, name, counter):
        threading.Thread.__init__(self)
        self.threadID = threadID
        self.name = name
        self.counter = counter
    def run(self):
        print ("开始线程：" + self.name)
        print_time(self.name, self.counter, 5)
        print ("退出线程：" + self.name)

def print_time(threadName, delay, counter):
    while counter:
        if exitFlag:
            threadName.exit()
        time.sleep(delay)
        print ("%s: %s" % (threadName, time.ctime(time.time())))
        counter -= 1

# 创建新线程
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)

# 开启新线程
thread1.start()
thread2.start()
thread1.join()
thread2.join()
print ("退出主线程")

  Hasil pelaksanaan program di atas adalah seperti berikut:

线程同步

  如果多个线程共同对某个数据修改，则可能出现不可预料的结果，为了保证数据的正确性，需要对多个线程进行同步。
  使用 Thread 对象的 Lock 和 Rlock 可以实现简单的线程同步，这两个对象都有 acquire 方法和 release 方法，对于那些需要每次只允许一个线程操作的数据，可以将其操作放到 acquire 和 release 方法之间。如下：
  多线程的优势在于可以同时运行多个任务（至少感觉起来是这样）。但是当线程需要共享数据时，可能存在数据不同步的问题。
  考虑这样一种情况：一个列表里所有元素都是0，线程"set"从后向前把所有元素改成1，而线程"print"负责从前往后读取列表并打印。
  那么，可能线程"set"开始改的时候，线程"print"便来打印列表了，输出就成了一半0一半1，这就是数据的不同步。为了避免这种情况，引入了锁的概念。
  锁有两种状态——锁定和未锁定。每当一个线程比如"set"要访问共享数据时，必须先获得锁定；如果已经有别的线程比如"print"获得锁定了，那么就让线程"set"暂停，也就是同步阻塞；等到线程"print"访问完毕，释放锁以后，再让线程"set"继续。
  经过这样的处理，打印列表时要么全部输出0，要么全部输出1，不会再出现一半0一半1的尴尬场面。
  实例：

#!/usr/bin/python3

import threading
import time

class myThread (threading.Thread):
    def __init__(self, threadID, name, counter):
        threading.Thread.__init__(self)
        self.threadID = threadID
        self.name = name
        self.counter = counter
    def run(self):
        print ("开启线程： " + self.name)
        # 获取锁，用于线程同步
        threadLock.acquire()
        print_time(self.name, self.counter, 3)
        # 释放锁，开启下一个线程
        threadLock.release()

def print_time(threadName, delay, counter):
    while counter:
        time.sleep(delay)
        print ("%s: %s" % (threadName, time.ctime(time.time())))
        counter -= 1

threadLock = threading.Lock()
threads = []

# 创建新线程
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)

# 开启新线程
thread1.start()
thread2.start()

# 添加线程到线程列表
threads.append(thread1)
threads.append(thread2)

# 等待所有线程完成
for t in threads:
    t.join()
print ("退出主线程")

  执行以上程序，输出结果为：

线程优先级队列（Queue）

  Python 的 Queue 模块中提供了同步的、线程安全的队列类，包括FIFO（先入先出)队列Queue，LIFO（后入先出）队列LifoQueue，和优先级队列 PriorityQueue。
  这些队列都实现了锁原语，能够在多线程中直接使用，可以使用队列来实现线程间的同步。
  Queue 模块中的常用方法:

• Queue.qsize() 返回队列的大小
• Queue.empty() 如果队列为空，返回True,反之False
• Queue.full() 如果队列满了，返回True,反之False
• Queue.full 与 maxsize 大小对应
• Queue.get([block[, timeout]])获取队列，timeout等待时间
• Queue.get_nowait() 相当Queue.get(False)
• Queue.put(item) 写入队列，timeout等待时间
• Queue.put_nowait(item) 相当Queue.put(item, False)
• Queue.task_done() 在完成一项工作之后，Queue.task_done()函数向任务已经完成的队列发送一个信号
• Queue.join() 实际上意味着等到队列为空，再执行别的操作

  实例:

#!/usr/bin/python3

import queue
import threading
import time

exitFlag = 0

class myThread (threading.Thread):
    def __init__(self, threadID, name, q):
        threading.Thread.__init__(self)
        self.threadID = threadID
        self.name = name
        self.q = q
    def run(self):
        print ("开启线程：" + self.name)
        process_data(self.name, self.q)
        print ("退出线程：" + self.name)

def process_data(threadName, q):
    while not exitFlag:
        queueLock.acquire()
        if not workQueue.empty():
            data = q.get()
            queueLock.release()
            print ("%s processing %s" % (threadName, data))
        else:
            queueLock.release()
        time.sleep(1)

threadList = ["Thread-1", "Thread-2", "Thread-3"]
nameList = ["One", "Two", "Three", "Four", "Five"]
queueLock = threading.Lock()
workQueue = queue.Queue(10)
threads = []
threadID = 1

# 创建新线程
for tName in threadList:
    thread = myThread(threadID, tName, workQueue)
    thread.start()
    threads.append(thread)
    threadID += 1

# 填充队列
queueLock.acquire()
for word in nameList:
    workQueue.put(word)
queueLock.release()

# 等待队列清空
while not workQueue.empty():
    pass

# 通知线程是时候退出
exitFlag = 1

# 等待所有线程完成
for t in threads:
    t.join()
print ("退出主线程")

  以上程序执行结果：

 推荐学习：python学习教程

Atas ialah kandungan terperinci Membawa anda untuk mentafsir Python multi-threading. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!