Hướng dẫn extending thread class in python - mở rộng lớp luồng trong python
Multithreading - Subclassing Thread Show bogotobogo.com site search: Python MultithreadCreating a thread and passing arguments to the thread run() methods So far, we've been using a thread by instantiating the Thread class given by the package (threading.py). To create our own thread in Python, we'll want to make our class to work as a thread. For this, we should subclass our class from the Thread class. First thing we need to do is to import Thread using the following code: from threading import Thread Then, we should subclass our class from the Thread class like this: class MyThread(Thread): Just for reference, here is a code snippet from the package for the Thread class: class Thread: ... def start(self): """Start the thread's activity. It must be called at most once per thread object. It arranges for the object's run() method to be invoked in a separate thread of control. This method will raise a RuntimeError if called more than once on the same thread object. """ if not self._initialized: raise RuntimeError("thread.__init__() not called") if self._started.is_set(): raise RuntimeError("threads can only be started once") with _active_limbo_lock: _limbo[self] = self try: _start_new_thread(self._bootstrap, ()) except Exception: with _active_limbo_lock: del _limbo[self] raise self._started.wait() def _bootstrap(self): try: self._bootstrap_inner() except: if self._daemonic and _sys is None: return raise def _bootstrap_inner(self): try: ... try: self.run() except SystemExit: pass except: def run(self): try: if self._target: self._target(*self._args, **self._kwargs) finally: # Avoid a refcycle if the thread is running a function with # an argument that has a member that points to the thread. del self._target, self._args, self._kwargs As a Thread starts up, it does some basic initialization and then calls its run() method, which calls the target function passed to the constructor. The Thread class represents an activity that runs in a separate thread of control. There are two ways to specify the activity:
No other methods (except for the constructor) should be overridden in a subclass. In other words, we only override the __init__() and run() methods of a class. In this section, we will create a subclass of Thread and override run() to do whatever is necessary: import threading class MyThread(threading.Thread): def run(self): pass if __name__ == '__main__': for i in range(3): t = MyThread() t.start() Once a thread object is created, its activity must be started by calling the thread's start() method. This invokes the run() method in a separate thread of control. Once the thread's activity is started, the thread is considered 'alive'. It stops being alive when its run() method terminates - either normally, or by raising an unhandled exception. The is_alive() method tests whether the thread is alive. import threading
import time
class MyThread(threading.Thread):
def run(self):
time.sleep(5)
return
if __name__ == '__main__':
for i in range(3):
t = MyThread()
t.start()
print 't.is_alive()=', t.is_alive()
t.join()
print 't.is_alive()=', t.is_alive()
Output: t.is_alive()= True t.is_alive()= False t.is_alive()= True t.is_alive()= False t.is_alive()= True t.is_alive()= False As we can see from the output, each of the three thread is alive just after the start but t.is_alive()=False after terminated. Before we move forward, for our convenience, let's put a logging feature into a place: import threading
import time
import logging
logging.basicConfig(level=logging.DEBUG,
format='(%(threadName)-9s) %(message)s',)
class MyThread(threading.Thread):
def run(self):
logging.debug('running')
return
if __name__ == '__main__':
for i in range(3):
t = MyThread()
t.start()
Output: (Thread-1 ) running (Thread-2 ) running (Thread-3 ) running Passing args to the customized thread Because the *args and **kwargs values passed to the Thread constructor are saved in private variables, they are not easily accessed from a subclass. To pass arguments to a custom thread type, we need to redefine the constructor to save the values in an instance attribute that can be seen in the subclass: import threading
import time
import logging
logging.basicConfig(level=logging.DEBUG,
format='(%(threadName)-9s) %(message)s',)
class MyThread(threading.Thread):
def __init__(self, group=None, target=None, name=None,
args=(), kwargs=None, verbose=None):
super(MyThread,self).__init__(group=group, target=target,
name=name, verbose=verbose)
self.args = args
self.kwargs = kwargs
return
def run(self):
logging.debug('running with %s and %s', self.args, self.kwargs)
return
if __name__ == '__main__':
for i in range(3):
t = MyThread(args=(i,), kwargs={'a':1, 'b':2})
t.start()
Output: (Thread-1 ) running with (0,) and {'a': 1, 'b': 2}
(Thread-2 ) running with (1,) and {'a': 1, 'b': 2}
(Thread-3 ) running with (2,) and {'a': 1, 'b': 2}
We overrided the __init__() using: class MyThread(Thread):0 For Python 3, we could have used without any args within the super(), like this: class MyThread(Thread):1 Python MultithreadCreating a thread and passing arguments to the thread Python tutorialPython Home Làm thế nào để bạn sử dụng lớp chủ đề trong Python?Lớp luồng đại diện cho một hoạt động được chạy trong một luồng điều khiển riêng biệt. Có hai cách để chỉ định hoạt động: bằng cách chuyển một đối tượng có thể gọi cho hàm tạo hoặc bằng cách ghi đè phương thức Run () trong một lớp con. Không có phương thức nào khác (ngoại trừ hàm tạo) nên được ghi đè trong một lớp con.by passing a callable object to the constructor, or by overriding the run() method in a subclass. No other methods (except for the constructor) should be overridden in a subclass.
Bạn có thể đa chủ đề trong Python?Python không hỗ trợ đa luồng vì Python trên trình thông dịch Cpython không hỗ trợ thực thi đa lõi thực sự thông qua đa luồng.Tuy nhiên, Python có một thư viện luồng.Gil không ngăn chặn luồng. because Python on the Cpython interpreter does not support true multi-core execution via multithreading. However, Python does have a threading library. The GIL does not prevent threading.
Làm cách nào để tạo một chủ đề tùy chỉnh trong Python?Tạo luồng bằng mô -đun luồng xác định một lớp con mới của lớp luồng.Ghi đè phương thức __init __ (self [, args]) để thêm các đối số bổ sung.Sau đó, ghi đè phương thức chạy (tự [, args]) để thực hiện những gì luồng nên làm khi bắt đầu.Define a new subclass of the Thread class. Override the __init__(self [,args]) method to add additional arguments. Then, override the run(self [,args]) method to implement what the thread should do when started.
Bạn có thể tạo một chủ đề bao nhiêu cách trong Python?Có hai cách tạo ra các chủ đề trong Python và đó là;sử dụng một lớp hoặc sử dụng một chức năng.using a class or using a function. |
