Penciptaan dan kaedah biasa benang Python (contoh terperinci)

Artikel ini membawakan anda pengetahuan yang berkaitan tentang python terutamanya memperkenalkan penciptaan dan kaedah biasa benang, serta beberapa kes demonstrasi benang Mari kita lihat bersama-sama.

Pembelajaran yang disyorkan: tutorial video python

Penciptaan dan penggunaan benang

Terdapat banyak modul berbilang benang dalam Python, antaranya modul threading lebih biasa digunakan. Mari kita lihat cara menggunakan threading untuk mencipta urutan dan kaedah biasanya.

Benang-Penciptaan Benang

函数名	介绍	举例
Thread	创建线程	Thread(target, args)

Pengenalan kepada tenaga kinetik Benang: Hidupkan rangkaian dengan memanggil kelas threading modul Thread Objek; ia mempunyai dua parameter: target 与 args (parameter yang sama seperti semasa membuat proses). target ialah fungsi yang akan dilaksanakan semasa mencipta benang, dan args ialah parameter yang perlu dihantar semasa melaksanakan fungsi ini.

Kaedah biasa objek benang

Mari kita lihat kaedah biasa objek benang:

函数名	介绍	用法
start	启动线程	start()
join	阻塞线程直到线程执行结束	join(timeout=None)
getName	获取线程的名字	getName()
setName	设置线程的名字	setName(name)
is_alive	判断线程是否存活	is_alive()
setDaemon	守护线程	setDaemon(True)

• fungsi mula: Mulakan utas; tidak mempunyai sebarang nilai atau parameter pulangan.
• fungsi sertai: Sama seperti fungsi gabungan dalam proses; menyekat program semasa, tugas utas utama perlu menunggu tugas sub-utas semasa tamat sebelum ia boleh meneruskan pelaksanaan; >: mewakili masa tamat masa menyekat. timeout
fungsi getName: Dapatkan nama urutan semasa.
• fungsi setName: tetapkan nama untuk utas semasa; parameternya ialah
• : ia adalah jenis rentetan name
fungsi is_alive: tentukan sama ada status utas semasa berada dalam stok
• Fungsi setDaemon: Ia adalah benang daemon; jika tugasan skrip dilaksanakan, ia akan ditamatkan secara paksa walaupun kumpulan proses belum menyelesaikan perniagaannya. Perkara yang sama berlaku untuk utas anak Jika anda mahu proses utama atau utas utama menyelesaikan urusannya sendiri terlebih dahulu, dan masih membenarkan utas anak terus berfungsi dan bukannya menutupnya secara paksa, anda hanya perlu menetapkan
• kepada <.>. setDaemon() True
PS: Melalui pengenalan di atas, anda akan mendapati bahawa fungsi dalam objek benang hampir hampir sama dengan fungsi dalam objek proses, dan kaedah penggunaan dan senario penggunaannya adalah hampir sama.

Kes Demonstrasi Benang

Kes Permulaan Benang Tunggal

Demonstrasi

Mari kita lihat kes berikut dahulu , selepas dijalankan, lihat berapa lama masa yang diambil secara keseluruhan

多线程之前

1. Tentukan senarai dan tulis beberapa kandungan di dalamnya.

2. Tentukan senarai baharu, tulis secara rawak kandungan senarai sebelumnya ke dalam senarai baharu dan padamkan kandungan yang diperoleh secara rawak daripada senarai sebelumnya.

3. Di sini anda perlu menggunakan

modul terbina dalam

r andom

Contoh kod adalah seperti berikut:

Hasil berjalan ialah seperti berikut:

# coding:utf-8import timeimport random


old_lists = ['罗马假日', '怦然心动', '时空恋旅人', '天使爱美丽', '天使之城', '倒霉爱神', '爱乐之城']new_lists = []def work():
    if len(old_lists) == 0:     # 判断 old_list 的长度，如果为0 ，则表示 该列表的内容已经被删光了
        return '\'old_list\' 列表内容已经全部删除'
    old_choice_data = random.choice(old_lists)      # random 模块的 choice函数可以随机获取传入的 old_list 的元素
    old_lists.remove(old_choice_data)               # 当获取到这个随机元素之后，将该元素从 old_lists 中删除
    new_choice_data = '%s_new' % old_choice_data    # 将随机获取到的随机元素通过格式化方式重新赋值，区别于之前的元素
    new_lists.append(new_choice_data)               # 将格式化的新的随机元素添加至 new_lists 列表

    time.sleep(1)if __name__ == '__main__':
    strat_time = time.time()

    for i in range(len(old_lists)):
        work()

    if len(old_lists) ==0:
        print('\'old_lists\' 当前为：{}'.format(None))
    else:
        print(('\'old_lists\' 当前为：{}'.format(old_lists)))

    if not len(new_lists) == 0:
        print(('\'new_lists\' 当前为：{}'.format(new_lists)))
    else:
        print('\'new_lists\' 当前为：{}'.format(None))

    end_time = time.time()
    print('运行结束，累计耗时：{} 秒'.format(end_time - strat_time))

---

Daripada hasil output yang sedang dijalankan, kita dapat melihat bahawa keseluruhan skrip mengambil masa 7 saat untuk dijalankan, dan elemen dalam senarai

ialah diformatkan dan ditambah dengan

; bukan sahaja Dengan cara ini, kerana new_lists, susunan kandungan _new juga berbeza daripada susunan larian akan berbeza setiap kali, jadi susunannya daripada random模块的choice函数 tidak boleh dijamin. new_listsold_listsold_listsKes demonstrasi berbilang benang

---

Contoh kod adalah seperti berikut:

Keputusan yang dijalankan adalah seperti berikut:

# coding:utf-8import timeimport randomimport threading


old_lists = ['罗马假日', '怦然心动', '时空恋旅人', '天使爱美丽', '天使之城', '倒霉爱神', '爱乐之城']new_lists = []def work():
    if len(old_lists) == 0:     # 判断 old_list 的长度，如果为0 ，则表示 该列表的内容已经被删光了
        return '\'old_list\' 列表内容已经全部删除'
    old_choice_data = random.choice(old_lists)      # random 模块的 choice函数可以随机获取传入的 old_list 的元素
    old_lists.remove(old_choice_data)               # 当获取到这个随机元素之后，将该元素从 old_lists 中删除
    new_choice_data = '%s_new' % old_choice_data    # 将随机获取到的随机元素通过格式化方式重新赋值，区别于之前的元素
    new_lists.append(new_choice_data)               # 将格式化的新的随机元素添加至 new_lists 列表

    time.sleep(1)if __name__ == '__main__':
    strat_time = time.time()

    print('\'old_lists\'初始长度为：{}'.format(len(old_lists)))	# 获取 old_lists 与 new_lists 最初始的长度
    print('\'new_lists\'初始长度为：{}'.format(len(new_lists)))
    thread_list = []        # 定义一个空的 thread_list 对象，用以下方添加每个线程

    for i in range(len(old_lists)):
        thread_work = threading.Thread(target=work)     # 定义一个线程实例化对象执行 work 函数，因为 work 函数没有参数所以不用传 args
        thread_list.append(thread_work)                 # 将 thread_work 添加进 thread_list
        thread_work.start()                             # 启动每一个线程

    for t in thread_list:   # 通过for循环将每一个线程进行阻塞
        t.join()

    if len(old_lists) ==0:
        print('\'old_lists\' 当前为：{}'.format(None), '当前长度为：{}'.format(len(old_lists)))
    else:
        print(('\'old_lists\' 当前为：{}'.format(old_lists)))

    if not len(new_lists) == 0:
        print('\'new_lists\' 当前长度为：{}'.format(len(new_lists)))
        print('\'new_lists\' 当前的值为：{}'.format(new_lists))
    else:
        print('\'new_lists\' 当前为：{}'.format(None))

    end_time = time.time()
    print('运行结束，累计耗时：{} 秒'.format(end_time - strat_time))

---

从运行的结果来看，我们初始的单线程任务耗时为 7秒，在使用多线程之后，仅耗时 1秒就完成了，大大的提高了我们的运行效率。 Masalah dengan Benang

---

Melalui latihan di atas, kami mendapati bahawa penggunaan benang hampir sama dengan iaitu proses. Mereka semua boleh melaksanakan program tanpa mengganggu satu sama lain, dan juga boleh menghalang program utas utama daripada menunggu tugas utas kanak-kanak selesai sebelum melaksanakannya. Cuma dalam kes demonstrasi tadi, kami menggunakan fungsi

untuk menyekat Anda boleh mengalih keluar

di sini untuk melihat kesan pelaksanaan.

join()Seperti proses, benang juga mempunyai masalah tertentu. join()

Fungsi yang dilaksanakan oleh benang juga tidak boleh mendapatkan nilai pulangan.

Apabila berbilang rangkaian mengubah suai fail pada masa yang sama, ia juga akan menyebabkan kekeliruan data dalam fail yang diubah suai (kerana fail dikendalikan secara serentak, terutamanya apabila berurusan dengan senario transaksi, perhatian khusus perlu diberikan).
• Masalah yang wujud dalam rangkaian ini juga boleh diselesaikan Kami akan memperkenalkannya secara terperinci dalam bab seterusnya
.

Pembelajaran yang disyorkan: 线程池与全局锁tutorial video python

Atas ialah kandungan terperinci Penciptaan dan kaedah biasa benang Python (contoh terperinci). Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!