How to use the thread module to create and manage threads in Python 2.x

How to use the thread module to create and manage threads in Python 2.x

Introduction:
In multi-threaded programming, we often need to create and manage multiple threads to implement concurrently executed tasks. Python provides the thread module to support multi-threaded programming. This article will introduce how to use the thread module to create and manage threads, and provide some code examples.

1. Thread module overview:
   The thread module provides some thread-related functions and classes for creating and managing threads. The following is a brief introduction to commonly used thread module functions and classes:

• thread.start_new_thread(function, args[, kwargs]): Create a new thread and execute the function function, args and kwargs are parameters passed to functions.
• thread.allocate_lock(): Create a new lock object for synchronization between threads.
• thread.exit(): The thread exits and ends the execution of the thread.
• thread.get_ident(): Get the identifier of the current thread.
• thread.interrupt_main(): Interrupt the execution of the main thread.
• thread.stack_size([size]): Get or set the thread stack size.

2. Example of creating a thread:
   The following example demonstrates how to use the thread module to create a thread.

import thread
import time

# 定义线程执行的函数
def print_time(threadName, delay):
    count = 0
    while count < 5:
        time.sleep(delay)
        count += 1
        print("%s: %s" % (threadName, time.ctime(time.time())))

# 创建两个线程
try:
    thread.start_new_thread(print_time, ("Thread-1", 2,))
    thread.start_new_thread(print_time, ("Thread-2", 4,))
except:
    print("Error: 无法启动线程")

# 主线程等待子线程结束
while 1:
    pass

Running the above code will create two threads that print the current time every 2 seconds and 4 seconds respectively. The main thread will wait for the child thread to end.

3. Thread synchronization and locking:
   In thread programming, it is often necessary to ensure the correct cooperation between multiple threads to avoid competition and conflicts. The thread module provides lock objects to achieve synchronization between threads. The following example shows how to use locks to guarantee mutually exclusive execution of threads.

import thread
import time

# 全局变量
counter = 0
lock = thread.allocate_lock()

# 线程函数
def increment_counter(threadName, delay):
    global counter
    while True:
        lock.acquire()
        counter += 1
        print("%s: %d" % (threadName, counter))
        lock.release()
        time.sleep(delay)

# 创建两个线程
try:
    thread.start_new_thread(increment_counter, ("Thread-1", 1,))
    thread.start_new_thread(increment_counter, ("Thread-2", 2,))
except:
    print("Error: 无法启动线程")

# 主线程等待子线程结束
while 1:
    pass

The above code creates two threads, increments the counter variable at different speeds and prints the results. Through the use of locks, mutually exclusive access to counter between threads is ensured, and race conditions are avoided.

Conclusion:
This article introduces the basic method of using the thread module to create and manage threads in Python 2.x, and provides some code examples. It is important to understand and master multi-threaded programming to improve the performance and responsiveness of your application. In actual development, you can also use more advanced and flexible multi-threading libraries, such as the threading module, which provides more functions and easier-to-use interfaces, but the basic principles and ideas are similar.

Reference materials:

• Python thread module documentation: https://docs.python.org/2/library/thread.html

The above is the detailed content of How to use the thread module to create and manage threads in Python 2.x. For more information, please follow other related articles on the PHP Chinese website!