Detailed explanation of examples of simple threads and coroutines in Python

The support for threads in python is indeed not enough, but it is said that python has a complete asynchronous network framework module. I hope to learn it in the future. Here is a brief summary of threads in python

threading library Can be used to execute arbitrary Python callable objects in a separate thread. Although this module does not have enough support for thread-related operations, we can still use simple threads to handle I/O operations to reduce program response time.

from threading import Thread
import time


def countdown(n):
    while n > 0:
        print('T-minus:', n)
        n -= 1


t = Thread(target=countdown, args=(10,))
t.start()  # 开启线程

time.sleep(2)

if t.is_alive() is True:
    print("停止线程...")
    t._stop()  # 停止线程

start function is used To start a thread, the _stop function is used to stop the thread. In order to prevent problems such as blocking when performing I/O operations in a thread, after running for a period of time, you can determine whether the thread is still alive. If the thread still exists, call _stop() to stop it to prevent blocking (you can encapsulate the _stop function into the class, I didn't do that here).

Of course, you can call the ThreadPool thread pool to handle it instead of manually creating threads. If there is no need to share variables between threads, it is very convenient to use threads, which can reduce a lot of troublesome operations and save time. If we need to communicate between threads, we can use a queue to achieve it:

from queue import Queue
from threading import Thread


class kill:
    def terminate(self, t):
        if t.isAlive is True:
            t._stop()


def product(out_q):
    for i in range(5):
            out_q.put(i)


def consumer(in_q):
    for i in range(5):
        print(in_q.get())


q = Queue()
t1 = Thread(target=consumer, args=(q,))
t2 = Thread(target=product, args=(q,))
t1.start()
t2.start()


k = kill()  # 查询线程是否终止，防止阻塞...
k.terminate(t1)
k.terminate(t2)

　

Queue instance will be shared by all threads, and it owns all required locks so they can be safely shared among any number of threads. Be careful here, do not use queue class methods other than put() and get() methods in multi-threads, because this is unreliable in a multi-thread environment! For simple and small communication of data in threads, queues can be used. If large data requires interactive communication, python provides related modules that you can use. The specific u need baidu.

The so-called coroutine is actually a yield program in a single-threaded environment.

from collections import deque


def countdown(n):
    while n > 0:
        print("T-minus", n)
        yield  # 返回之后下次直接从这里执行...相当于C#里面得yield return .
        n -= 1
    print("this is countdown!!!")


def countup(n):
    x = 0
    while x < n:
        print("Counting up", x)
        yield
        x += 1


class TaskScheduler:
    def __init__(self):
        self._task_queue = deque()

    def new_task(self, task):
        self._task_queue.append(task)

    def run(self):
        while self._task_queue:
            task = self._task_queue.popleft()
            try:
                next(task)
                self._task_queue.append(task)
            except StopIteration:
                pass


sche = TaskScheduler()
sche.new_task(countdown(10))
sche.new_task(countdown(5))
sche.new_task(countup(15))
sche.run()

Let me talk about my experience of using python during this period. python is indeed good, but its performance is also criticized. When I first started learning python, I also made some cool programs. , at least it sounds high-quality, such as using Python's natural language processing to do sentiment analysis and the hottest crawler programs, as well as making dazzling data analysis charts. Gradually, I let go of those, because the focus of the program is not on those. As long as you know the basic syntax and understand the official documents, you can make it. The focus of the program code is performance and optimization. To the greatest extent possible, write a program with the most complete functions, the best performance, and the most beautiful structure. In fact, this is a bit like the "cultural soft power" that political teachers often say. The "soft power" in a program should be to embed the most Suitable design patterns, the most complete program optimization, the most performance-efficient data structures, etc.

The above is the detailed content of Detailed explanation of examples of simple threads and coroutines in Python. For more information, please follow other related articles on the PHP Chinese website!