Hàm foodưới đây trả về một chuỗi 'foo'. Làm thế nào tôi có thể nhận được giá trị 'foo'được trả về từ mục tiêu của luồng?

from threading import Thread

def foo(bar):
    print('hello {}'.format(bar))
    return 'foo'

thread = Thread(target=foo, args=('world!',))
thread.start()
return_value = thread.join()

"Một cách rõ ràng để làm điều đó", được hiển thị ở trên, không hoạt động: thread.join()trả lại None.

Trong Python 3.2+, concurrent.futuresmô-đun stdlib cung cấp API cấp cao hơn threading, bao gồm chuyển các giá trị trả về hoặc ngoại lệ từ luồng công nhân trở lại luồng chính:

import concurrent.futures

def foo(bar):
    print('hello {}'.format(bar))
    return 'foo'

with concurrent.futures.ThreadPoolExecutor() as executor:
    future = executor.submit(foo, 'world!')
    return_value = future.result()
    print(return_value)

FWIW, multiprocessingmô-đun có một giao diện đẹp cho việc này bằng cách sử dụng Poollớp. Và nếu bạn muốn gắn bó với các luồng hơn là các tiến trình, bạn chỉ có thể sử dụng multiprocessing.pool.ThreadPoollớp này như một sự thay thế thả vào.

def foo(bar, baz):
  print 'hello {0}'.format(bar)
  return 'foo' + baz

from multiprocessing.pool import ThreadPool
pool = ThreadPool(processes=1)

async_result = pool.apply_async(foo, ('world', 'foo')) # tuple of args for foo

# do some other stuff in the main process

return_val = async_result.get()  # get the return value from your function.

Một cách tôi đã thấy là chuyển một đối tượng có thể thay đổi, chẳng hạn như danh sách hoặc từ điển, đến hàm tạo của luồng, cùng với một chỉ mục hoặc mã định danh khác thuộc loại nào đó. Sau đó, luồng có thể lưu trữ kết quả của nó trong khe chuyên dụng của nó trong đối tượng đó. Ví dụ:

def foo(bar, result, index):
    print 'hello {0}'.format(bar)
    result[index] = "foo"

from threading import Thread

threads = [None] * 10
results = [None] * 10

for i in range(len(threads)):
    threads[i] = Thread(target=foo, args=('world!', results, i))
    threads[i].start()

# do some other stuff

for i in range(len(threads)):
    threads[i].join()

print " ".join(results)  # what sound does a metasyntactic locomotive make?

Nếu bạn thực sự muốn join()trả về giá trị trả về của hàm được gọi, bạn có thể thực hiện việc này với một Threadlớp con như sau:

from threading import Thread

def foo(bar):
    print 'hello {0}'.format(bar)
    return "foo"

class ThreadWithReturnValue(Thread):
    def __init__(self, group=None, target=None, name=None,
                 args=(), kwargs={}, Verbose=None):
        Thread.__init__(self, group, target, name, args, kwargs, Verbose)
        self._return = None
    def run(self):
        if self._Thread__target is not None:
            self._return = self._Thread__target(*self._Thread__args,
                                                **self._Thread__kwargs)
    def join(self):
        Thread.join(self)
        return self._return

twrv = ThreadWithReturnValue(target=foo, args=('world!',))

twrv.start()
print twrv.join()   # prints foo

Điều đó có một chút lông vì một số tên xáo trộn, và nó truy cập các cấu trúc dữ liệu "riêng tư" dành riêng cho Threadviệc thực hiện ... nhưng nó hoạt động.

Cho trăn3

class ThreadWithReturnValue(Thread):
    def __init__(self, group=None, target=None, name=None,
                 args=(), kwargs={}, Verbose=None):
        Thread.__init__(self, group, target, name, args, kwargs)
        self._return = None
    def run(self):
        print(type(self._target))
        if self._target is not None:
            self._return = self._target(*self._args,
                                                **self._kwargs)
    def join(self, *args):
        Thread.join(self, *args)
        return self._return

Câu trả lời của Jake là tốt, nhưng nếu bạn không muốn sử dụng một luồng (bạn không biết bạn cần bao nhiêu luồng, nhưng tạo chúng khi cần) thì một cách tốt để truyền thông tin giữa các luồng là tích hợp Lớp Queue.Queue , vì nó cung cấp sự an toàn của luồng.

Tôi đã tạo ra trình trang trí sau đây để làm cho nó hoạt động theo kiểu tương tự như luồng:

def threaded(f, daemon=False):
    import Queue

    def wrapped_f(q, *args, **kwargs):
        '''this function calls the decorated function and puts the 
        result in a queue'''
        ret = f(*args, **kwargs)
        q.put(ret)

    def wrap(*args, **kwargs):
        '''this is the function returned from the decorator. It fires off
        wrapped_f in a new thread and returns the thread object with
        the result queue attached'''

        q = Queue.Queue()

        t = threading.Thread(target=wrapped_f, args=(q,)+args, kwargs=kwargs)
        t.daemon = daemon
        t.start()
        t.result_queue = q        
        return t

    return wrap

Sau đó, bạn chỉ cần sử dụng nó như:

@threaded
def long_task(x):
    import time
    x = x + 5
    time.sleep(5)
    return x

# does not block, returns Thread object
y = long_task(10)
print y

# this blocks, waiting for the result
result = y.result_queue.get()
print result

Hàm được trang trí tạo ra một luồng mới mỗi lần nó được gọi và trả về một đối tượng Thread chứa hàng đợi sẽ nhận kết quả.

CẬP NHẬT

Đã khá lâu kể từ khi tôi đăng câu trả lời này, nhưng nó vẫn nhận được lượt xem vì vậy tôi nghĩ rằng tôi sẽ cập nhật nó để phản ánh cách tôi làm điều này trong các phiên bản Python mới hơn:

Python 3.2 được thêm vào trong concurrent.futuresmô-đun cung cấp giao diện cấp cao cho các tác vụ song song. Nó cung cấp ThreadPoolExecutorvà ProcessPoolExecutor, vì vậy bạn có thể sử dụng một luồng hoặc xử lý nhóm với cùng một api.

Một lợi ích của api này là việc gửi một tác vụ tới Executormột Futuređối tượng trả về , nó sẽ hoàn thành với giá trị trả về của hàm có thể gọi được mà bạn gửi.

Điều này làm cho việc gắn một queueđối tượng không cần thiết, giúp đơn giản hóa trang trí khá nhiều:

_DEFAULT_POOL = ThreadPoolExecutor()

def threadpool(f, executor=None):
    @wraps(f)
    def wrap(*args, **kwargs):
        return (executor or _DEFAULT_POOL).submit(f, *args, **kwargs)

    return wrap

Điều này sẽ sử dụng một trình thực thi luồng mô-đun mặc định nếu một không được truyền vào.

Cách sử dụng rất giống với trước đây:

@threadpool
def long_task(x):
    import time
    x = x + 5
    time.sleep(5)
    return x

# does not block, returns Future object
y = long_task(10)
print y

# this blocks, waiting for the result
result = y.result()
print result

Nếu bạn đang sử dụng Python 3.4 trở lên, một trong những tính năng thật sự tốt đẹp của việc sử dụng phương pháp này (và các đối tượng trong tương lai nói chung) là tương lai trở lại có thể được bao bọc để biến nó thành một asyncio.Futurevới asyncio.wrap_future. Điều này làm cho nó hoạt động dễ dàng với coroutines:

result = await asyncio.wrap_future(long_task(10))

Nếu bạn không cần quyền truy cập vào concurrent.Futuređối tượng cơ bản , bạn có thể bao gồm phần bọc trong trang trí:

_DEFAULT_POOL = ThreadPoolExecutor()

def threadpool(f, executor=None):
    @wraps(f)
    def wrap(*args, **kwargs):
        return asyncio.wrap_future((executor or _DEFAULT_POOL).submit(f, *args, **kwargs))

    return wrap

Sau đó, bất cứ khi nào bạn cần đẩy cpu chuyên sâu hoặc chặn mã khỏi chuỗi vòng lặp sự kiện, bạn có thể đặt nó vào một chức năng được trang trí:

@threadpool
def some_long_calculation():
    ...

# this will suspend while the function is executed on a threadpool
result = await some_long_calculation()

Một giải pháp khác không yêu cầu thay đổi mã hiện tại của bạn:

import Queue
from threading import Thread

def foo(bar):
    print 'hello {0}'.format(bar)
    return 'foo'

que = Queue.Queue()

t = Thread(target=lambda q, arg1: q.put(foo(arg1)), args=(que, 'world!'))
t.start()
t.join()
result = que.get()
print result

Nó cũng có thể dễ dàng điều chỉnh theo môi trường đa luồng:

import Queue
from threading import Thread

def foo(bar):
    print 'hello {0}'.format(bar)
    return 'foo'

que = Queue.Queue()
threads_list = list()

t = Thread(target=lambda q, arg1: q.put(foo(arg1)), args=(que, 'world!'))
t.start()
threads_list.append(t)

# Add more threads here
...
threads_list.append(t2)
...
threads_list.append(t3)
...

# Join all the threads
for t in threads_list:
    t.join()

# Check thread's return value
while not que.empty():
    result = que.get()
    print result

Câu trả lời join / câu trả lời của Parris / kindall returnđược chuyển sang Python 3:

from threading import Thread

def foo(bar):
    print('hello {0}'.format(bar))
    return "foo"

class ThreadWithReturnValue(Thread):
    def __init__(self, group=None, target=None, name=None, args=(), kwargs=None, *, daemon=None):
        Thread.__init__(self, group, target, name, args, kwargs, daemon=daemon)

        self._return = None

    def run(self):
        if self._target is not None:
            self._return = self._target(*self._args, **self._kwargs)

    def join(self):
        Thread.join(self)
        return self._return


twrv = ThreadWithReturnValue(target=foo, args=('world!',))

twrv.start()
print(twrv.join())   # prints foo

Lưu ý, Threadlớp được triển khai khác nhau trong Python 3.

Tôi đã đánh cắp câu trả lời của kindall và làm sạch nó chỉ một chút.

Phần quan trọng là thêm * args và ** kwargs để tham gia () để xử lý thời gian chờ

class threadWithReturn(Thread):
    def __init__(self, *args, **kwargs):
        super(threadWithReturn, self).__init__(*args, **kwargs)

        self._return = None

    def run(self):
        if self._Thread__target is not None:
            self._return = self._Thread__target(*self._Thread__args, **self._Thread__kwargs)

    def join(self, *args, **kwargs):
        super(threadWithReturn, self).join(*args, **kwargs)

        return self._return

CẬP NHẬT TRẢ LỜI DƯỚI ĐÂY

Đây là câu trả lời phổ biến nhất của tôi, vì vậy tôi quyết định cập nhật với mã sẽ chạy trên cả py2 và py3.

Ngoài ra, tôi thấy nhiều câu trả lời cho câu hỏi này cho thấy sự thiếu hiểu biết về Thread.join (). Một số hoàn toàn không xử lý các timeoutarg. Nhưng cũng có một trường hợp góc mà bạn cần lưu ý về các trường hợp khi bạn có (1) một hàm mục tiêu có thể trả về Nonevà (2) bạn cũng chuyển đối số timeoutđể tham gia (). Vui lòng xem "KIỂM TRA 4" để hiểu trường hợp góc này.

Lớp ThreadWithReturn hoạt động với py2 và py3:

import sys
from threading import Thread
from builtins import super    # https://stackoverflow.com/a/30159479

if sys.version_info >= (3, 0):
    _thread_target_key = '_target'
    _thread_args_key = '_args'
    _thread_kwargs_key = '_kwargs'
else:
    _thread_target_key = '_Thread__target'
    _thread_args_key = '_Thread__args'
    _thread_kwargs_key = '_Thread__kwargs'

class ThreadWithReturn(Thread):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self._return = None

    def run(self):
        target = getattr(self, _thread_target_key)
        if not target is None:
            self._return = target(
                *getattr(self, _thread_args_key),
                **getattr(self, _thread_kwargs_key)
            )

    def join(self, *args, **kwargs):
        super().join(*args, **kwargs)
        return self._return

Một số thử nghiệm mẫu được hiển thị dưới đây:

import time, random

# TEST TARGET FUNCTION
def giveMe(arg, seconds=None):
    if not seconds is None:
        time.sleep(seconds)
    return arg

# TEST 1
my_thread = ThreadWithReturn(target=giveMe, args=('stringy',))
my_thread.start()
returned = my_thread.join()
# (returned == 'stringy')

# TEST 2
my_thread = ThreadWithReturn(target=giveMe, args=(None,))
my_thread.start()
returned = my_thread.join()
# (returned is None)

# TEST 3
my_thread = ThreadWithReturn(target=giveMe, args=('stringy',), kwargs={'seconds': 5})
my_thread.start()
returned = my_thread.join(timeout=2)
# (returned is None) # because join() timed out before giveMe() finished

# TEST 4
my_thread = ThreadWithReturn(target=giveMe, args=(None,), kwargs={'seconds': 5})
my_thread.start()
returned = my_thread.join(timeout=random.randint(1, 10))

Bạn có thể xác định trường hợp góc mà chúng ta có thể gặp phải với TEST 4 không?

Vấn đề là chúng tôi hy vọng giveMe () sẽ trả về Không (xem TEST 2), nhưng chúng tôi cũng mong tham gia () sẽ trả về Không nếu hết thời gian.

returned is None có nghĩa là:

(1) đó là những gì giveMe () đã trả lại hoặc

(2) tham gia () đã hết thời gian

Ví dụ này là tầm thường vì chúng ta biết rằng giveMe () sẽ luôn trả về Không. Nhưng trong trường hợp thực tế (nơi mục tiêu có thể trả lại hợp pháp Không có gì hoặc điều gì khác), chúng tôi muốn kiểm tra rõ ràng những gì đã xảy ra.

Dưới đây là cách giải quyết trường hợp góc này:

# TEST 4
my_thread = ThreadWithReturn(target=giveMe, args=(None,), kwargs={'seconds': 5})
my_thread.start()
returned = my_thread.join(timeout=random.randint(1, 10))

if my_thread.isAlive():
    # returned is None because join() timed out
    # this also means that giveMe() is still running in the background
    pass
    # handle this based on your app's logic
else:
    # join() is finished, and so is giveMe()
    # BUT we could also be in a race condition, so we need to update returned, just in case
    returned = my_thread.join()

Sử dụng hàng đợi:

import threading, queue

def calc_square(num, out_queue1):
  l = []
  for x in num:
    l.append(x*x)
  out_queue1.put(l)


arr = [1,2,3,4,5,6,7,8,9,10]
out_queue1=queue.Queue()
t1=threading.Thread(target=calc_square, args=(arr,out_queue1))
t1.start()
t1.join()
print (out_queue1.get())

Giải pháp của tôi cho vấn đề này là bọc hàm và luồng trong một lớp. Không yêu cầu sử dụng nhóm, hàng đợi hoặc biến loại c đi qua. Nó cũng không chặn. Bạn kiểm tra trạng thái thay thế. Xem ví dụ về cách sử dụng nó ở cuối mã.

import threading

class ThreadWorker():
    '''
    The basic idea is given a function create an object.
    The object can then run the function in a thread.
    It provides a wrapper to start it,check its status,and get data out the function.
    '''
    def __init__(self,func):
        self.thread = None
        self.data = None
        self.func = self.save_data(func)

    def save_data(self,func):
        '''modify function to save its returned data'''
        def new_func(*args, **kwargs):
            self.data=func(*args, **kwargs)

        return new_func

    def start(self,params):
        self.data = None
        if self.thread is not None:
            if self.thread.isAlive():
                return 'running' #could raise exception here

        #unless thread exists and is alive start or restart it
        self.thread = threading.Thread(target=self.func,args=params)
        self.thread.start()
        return 'started'

    def status(self):
        if self.thread is None:
            return 'not_started'
        else:
            if self.thread.isAlive():
                return 'running'
            else:
                return 'finished'

    def get_results(self):
        if self.thread is None:
            return 'not_started' #could return exception
        else:
            if self.thread.isAlive():
                return 'running'
            else:
                return self.data

def add(x,y):
    return x +y

add_worker = ThreadWorker(add)
print add_worker.start((1,2,))
print add_worker.status()
print add_worker.get_results()

joinluôn luôn trả về None, tôi nghĩ bạn nên phân lớp Threadđể xử lý mã trả về và vì vậy.

Cân nhắc @iman bình luận về câu trả lời @JakeBiesinger Tôi đã viết lại nó để có số lượng chủ đề khác nhau:

from multiprocessing.pool import ThreadPool

def foo(bar, baz):
    print 'hello {0}'.format(bar)
    return 'foo' + baz

numOfThreads = 3 
results = []

pool = ThreadPool(numOfThreads)

for i in range(0, numOfThreads):
    results.append(pool.apply_async(foo, ('world', 'foo'))) # tuple of args for foo)

# do some other stuff in the main process
# ...
# ...

results = [r.get() for r in results]
print results

pool.close()
pool.join()

Chúc mừng

Chàng.

Bạn có thể định nghĩa một biến đổi trên phạm vi của hàm luồng và thêm kết quả vào đó. (Tôi cũng đã sửa đổi mã để tương thích với python3)

returns = {}
def foo(bar):
    print('hello {0}'.format(bar))
    returns[bar] = 'foo'

from threading import Thread
t = Thread(target=foo, args=('world!',))
t.start()
t.join()
print(returns)

Điều này trở lại {'world!': 'foo'}

Nếu bạn sử dụng đầu vào chức năng làm chìa khóa cho kết quả của mình, mọi đầu vào duy nhất được đảm bảo để đưa ra một mục trong kết quả

Tôi đang sử dụng trình bao bọc này, giúp thoải mái chuyển bất kỳ chức năng nào để chạy trong Thread- chăm sóc giá trị trả về hoặc ngoại lệ của nó. Nó không thêm Queuechi phí.

def threading_func(f):
    """Decorator for running a function in a thread and handling its return
    value or exception"""
    def start(*args, **kw):
        def run():
            try:
                th.ret = f(*args, **kw)
            except:
                th.exc = sys.exc_info()
        def get(timeout=None):
            th.join(timeout)
            if th.exc:
                raise th.exc[0], th.exc[1], th.exc[2] # py2
                ##raise th.exc[1] #py3                
            return th.ret
        th = threading.Thread(None, run)
        th.exc = None
        th.get = get
        th.start()
        return th
    return start

Ví dụ sử dụng

def f(x):
    return 2.5 * x
th = threading_func(f)(4)
print("still running?:", th.is_alive())
print("result:", th.get(timeout=1.0))

@threading_func
def th_mul(a, b):
    return a * b
th = th_mul("text", 2.5)

try:
    print(th.get())
except TypeError:
    print("exception thrown ok.")

Ghi chú về threadingmô-đun

Giá trị trả về thoải mái và xử lý ngoại lệ của hàm luồng là nhu cầu "Pythonic" thường xuyên và thực sự đã được cung cấp bởi threadingmô-đun - có thể trực tiếp trong Threadlớp tiêu chuẩn . ThreadPoolcó quá nhiều chi phí cho các nhiệm vụ đơn giản - 3 luồng quản lý, rất nhiều quan liêu. Thật không may Thread, bố cục của nó đã được sao chép từ Java ban đầu - mà bạn thấy, ví dụ như từ tham số hàm tạo 1st (!) Vẫn vô dụng group.

Xác định mục tiêu của bạn thành
1) lấy một đối số q
2) thay thế bất kỳ câu lệnh nào return foobằngq.put(foo); return

một chức năng

def func(a):
    ans = a * a
    return ans

sẽ trở thành

def func(a, q):
    ans = a * a
    q.put(ans)
    return

và sau đó bạn sẽ tiến hành như vậy

from Queue import Queue
from threading import Thread

ans_q = Queue()
arg_tups = [(i, ans_q) for i in xrange(10)]

threads = [Thread(target=func, args=arg_tup) for arg_tup in arg_tups]
_ = [t.start() for t in threads]
_ = [t.join() for t in threads]
results = [q.get() for _ in xrange(len(threads))]

Và bạn có thể sử dụng các hàm trang trí / hàm bao để làm cho nó để bạn có thể sử dụng các hàm hiện có của mình targetmà không cần sửa đổi chúng, nhưng hãy làm theo sơ đồ cơ bản này.

Như đã đề cập nhóm đa xử lý chậm hơn nhiều so với phân luồng cơ bản. Sử dụng hàng đợi như đề xuất trong một số câu trả lời ở đây là một cách thay thế rất hiệu quả. Tôi đã sử dụng nó với từ điển để có thể chạy rất nhiều chủ đề nhỏ và thu hồi nhiều câu trả lời bằng cách kết hợp chúng với từ điển:

#!/usr/bin/env python3

import threading
# use Queue for python2
import queue
import random

LETTERS = 'abcdefghijklmnopqrstuvwxyz'
LETTERS = [ x for x in LETTERS ]

NUMBERS = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

def randoms(k, q):
    result = dict()
    result['letter'] = random.choice(LETTERS)
    result['number'] = random.choice(NUMBERS)
    q.put({k: result})

threads = list()
q = queue.Queue()
results = dict()

for name in ('alpha', 'oscar', 'yankee',):
    threads.append( threading.Thread(target=randoms, args=(name, q)) )
    threads[-1].start()
_ = [ t.join() for t in threads ]
while not q.empty():
    results.update(q.get())

print(results)

Ý tưởng của GuySoft là tuyệt vời, nhưng tôi nghĩ rằng đối tượng không nhất thiết phải kế thừa từ Thread và start () có thể bị xóa khỏi giao diện:

from threading import Thread
import queue
class ThreadWithReturnValue(object):
    def __init__(self, target=None, args=(), **kwargs):
        self._que = queue.Queue()
        self._t = Thread(target=lambda q,arg1,kwargs1: q.put(target(*arg1, **kwargs1)) ,
                args=(self._que, args, kwargs), )
        self._t.start()

    def join(self):
        self._t.join()
        return self._que.get()


def foo(bar):
    print('hello {0}'.format(bar))
    return "foo"

twrv = ThreadWithReturnValue(target=foo, args=('world!',))

print(twrv.join())   # prints foo

Một giải pháp thông thường là bọc chức năng của bạn foovới một trình trang trí như

result = queue.Queue()

def task_wrapper(*args):
    result.put(target(*args))

Sau đó, toàn bộ mã có thể trông như thế

result = queue.Queue()

def task_wrapper(*args):
    result.put(target(*args))

threads = [threading.Thread(target=task_wrapper, args=args) for args in args_list]

for t in threads:
    t.start()
    while(True):
        if(len(threading.enumerate()) < max_num):
            break
for t in threads:
    t.join()
return result

Ghi chú

Một vấn đề quan trọng là các giá trị trả về có thể không được điều chỉnh . (Trong thực tế, return valuekhông nhất thiết phải được lưu vào queue, vì bạn có thể chọn cấu trúc dữ liệu an toàn luồng tùy ý )

Tại sao không sử dụng biến toàn cầu?

import threading


class myThread(threading.Thread):
    def __init__(self, ind, lock):
        threading.Thread.__init__(self)
        self.ind = ind
        self.lock = lock

    def run(self):
        global results
        with self.lock:
            results.append(self.ind)



results = []
lock = threading.Lock()
threads = [myThread(x, lock) for x in range(1, 4)]
for t in threads:
    t.start()
for t in threads:
    t.join()
print(results)

Câu trả lời của Kindall trong Python3

class ThreadWithReturnValue(Thread):
    def __init__(self, group=None, target=None, name=None,
                 args=(), kwargs={}, *, daemon=None):
        Thread.__init__(self, group, target, name, args, kwargs, daemon)
        self._return = None 

    def run(self):
        try:
            if self._target:
                self._return = self._target(*self._args, **self._kwargs)
        finally:
            del self._target, self._args, self._kwargs 

    def join(self,timeout=None):
        Thread.join(self,timeout)
        return self._return

Nếu chỉ có Đúng hoặc Sai được xác thực từ lệnh gọi của hàm, một giải pháp đơn giản hơn mà tôi tìm thấy là cập nhật danh sách toàn cầu.

import threading

lists = {"A":"True", "B":"True"}

def myfunc(name: str, mylist):
    for i in mylist:
        if i == 31:
            lists[name] = "False"
            return False
        else:
            print("name {} : {}".format(name, i))

t1 = threading.Thread(target=myfunc, args=("A", [1, 2, 3, 4, 5, 6], ))
t2 = threading.Thread(target=myfunc, args=("B", [11, 21, 31, 41, 51, 61], ))
t1.start()
t2.start()
t1.join()
t2.join()

for value in lists.values():
    if value == False:
        # Something is suspicious 
        # Take necessary action 

Điều này hữu ích hơn khi bạn muốn tìm nếu bất kỳ một trong các luồng đã trả về trạng thái sai để thực hiện hành động cần thiết.