Summary of threads and coroutines in python

The editor below will bring you an article (share) on learning python simple threads and coroutines. The editor thinks it’s pretty good, so I’ll share it with you now and give it as a reference. Let’s follow the editor and take a look.

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 about it in the future. Here is a simple introduction to threads in python. To summarize

The 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() # 停止线程

The start function is used to start the thread, and 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 queues 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 instances will be shared by all threads, and at the same time it has all the required locks, so they can be safe is 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()

Here I would like to 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 comparisons. Stunning programs, at least sound 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 pattern, do the most complete program optimization, adopt the most performance-saving data structure, etc.

The above is the detailed content of Summary of threads and coroutines in python. For more information, please follow other related articles on the PHP Chinese website!