Corak Concurrency: Objek Aktif

pengenalan

Corak Objek Aktif ialah corak reka bentuk serentak yang memisahkan pelaksanaan kaedah daripada seruan kaedah. Matlamat utama corak ini adalah untuk memperkenalkan tingkah laku tak segerak dengan melaksanakan operasi dalam urutan berasingan, sambil menyediakan antara muka segerak kepada klien. Ini dicapai menggunakan gabungan penghantaran mesej, baris gilir permintaan dan mekanisme penjadualan.

Komponen Utama

1. Proksi: Mewakili antara muka awam kepada pelanggan. Dalam istilah yang lebih mudah, ini adalah perkara yang pelanggan akan berinteraksi. Ia menterjemahkan panggilan kaedah kepada permintaan untuk objek aktif.
2. Penjadual: Mengurus baris gilir permintaan dan menentukan susunan pelaksanaan permintaan.
3. Hamba: Mengandungi pelaksanaan sebenar kaedah yang digunakan. Di sinilah logik pengiraan sebenar pergi.
4. Baris Gilir Pengaktifan: Menyimpan permintaan daripada proksi sehingga penjadual memprosesnya.
5. Masa Depan/Panggil Balik: Pemegang tempat untuk hasil pengiraan tak segerak.

Aliran kerja

1. Pelanggan menggunakan kaedah pada proksi.
2. Proksi membuat permintaan dan meletakkannya dalam baris gilir pengaktifan.
3. Penjadual mengambil permintaan dan memajukannya kepada pelayan untuk dilaksanakan.
4. Hasilnya dikembalikan kepada pelanggan melalui objek masa hadapan.

Kes Penggunaan

• Sistem masa nyata yang memerlukan corak pelaksanaan yang boleh diramal.
• Aplikasi GUI untuk memastikan urutan utama responsif.
• Sistem teragih untuk mengendalikan permintaan tak segerak.

Perlaksanaan

Katakanlah kita perlu melakukan pengiraan, mungkin panggilan API, pertanyaan pangkalan data, dll. Saya tidak akan melaksanakan sebarang pengendalian pengecualian kerana saya terlalu malas.

def compute(x, y):
    time.sleep(2)  # Some time taking task
    return x + y

Tanpa Corak Objek Aktif

Di bawah ialah contoh cara kami mengendalikan permintaan serentak tanpa menggunakan Corak Objek Aktif.

import threading
import time


def main():
    # Start threads directly
    results = {}

    def worker(task_id, x, y):
        results[task_id] = compute(x, y)

    print("Submitting tasks...")
    thread1 = threading.Thread(target=worker, args=(1, 5, 10))
    thread2 = threading.Thread(target=worker, args=(2, 15, 20))

    thread1.start()
    thread2.start()

    print("Doing other work...")

    thread1.join()
    thread2.join()

    # Retrieve results
    print("Result 1:", results[1])
    print("Result 2:", results[2])


if __name__ == "__main__":
    main()

Kelemahan Pendekatan Di Atas

• Pengurusan Benang: Pengurusan rangkaian secara langsung meningkatkan kerumitan, terutamanya apabila bilangan tugasan bertambah.

• Kurang Abstraksi: Pelanggan bertanggungjawab menguruskan kitaran hayat benang, menggabungkan pengurusan tugasan dengan logik perniagaan.

• Isu Kebolehskalaan: Tanpa baris gilir atau mekanisme penjadualan yang betul, tiada kawalan ke atas perintah pelaksanaan tugas.

• Tindak Balas Terhad: Pelanggan perlu menunggu urutan untuk menyertai sebelum mengakses keputusan.

Pelaksanaan menggunakan Corak Objek Aktif

Di bawah ialah pelaksanaan Python bagi Corak Objek Aktif menggunakan benang dan baris gilir untuk melakukan perkara yang sama seperti di atas. Kami akan menelusuri setiap bahagian satu demi satu:

MethodRequest: Merangkumkan kaedah, hujah dan Masa Depan untuk menyimpan hasilnya.

def compute(x, y):
    time.sleep(2)  # Some time taking task
    return x + y

Penjadual: Memproses permintaan secara berterusan daripada activation_queue dalam urutan yang berasingan.

import threading
import time


def main():
    # Start threads directly
    results = {}

    def worker(task_id, x, y):
        results[task_id] = compute(x, y)

    print("Submitting tasks...")
    thread1 = threading.Thread(target=worker, args=(1, 5, 10))
    thread2 = threading.Thread(target=worker, args=(2, 15, 20))

    thread1.start()
    thread2.start()

    print("Doing other work...")

    thread1.join()
    thread2.join()

    # Retrieve results
    print("Result 1:", results[1])
    print("Result 2:", results[2])


if __name__ == "__main__":
    main()

Hamba: Melaksanakan logik sebenar (cth., kaedah pengiraan).

class MethodRequest:
    def __init__(self, method, args, kwargs, future):
        self.method = method
        self.args = args
        self.kwargs = kwargs
        self.future = future

    def execute(self):
        try:
            result = self.method(*self.args, **self.kwargs)
            self.future.set_result(result)
        except Exception as e:
            self.future.set_exception(e)

Proksi: Menterjemah panggilan kaedah kepada permintaan dan mengembalikan Masa Depan untuk hasilnya.

import threading
import queue


class Scheduler(threading.Thread):
    def __init__(self):
        super().__init__()
        self.activation_queue = queue.Queue()
        self._stop_event = threading.Event()

    def enqueue(self, request):
        self.activation_queue.put(request)

    def run(self):
        while not self._stop_event.is_set():
            try:
                request = self.activation_queue.get(timeout=0.1)
                request.execute()
            except queue.Empty:
                continue

    def stop(self):
        self._stop_event.set()
        self.join()

Pelanggan: Menyerahkan tugasan secara tidak segerak dan mendapatkan semula keputusan apabila diperlukan.

import time


class Servant:
    def compute(self, x, y):
        time.sleep(2)
        return x + y

Kelebihan

• Antara Muka Dipisahkan: Pelanggan boleh menggunakan kaedah tanpa perlu risau tentang butiran pelaksanaan.
• Responsif: Pelaksanaan tak segerak memastikan pelanggan kekal responsif.
• Skalabiliti: Menyokong berbilang permintaan serentak.

Keburukan

• Kerumitan: Meningkatkan kerumitan seni bina.
• Overhed: Memerlukan sumber tambahan untuk mengurus urutan dan baris gilir.
• Latensi: Pemprosesan tak segerak mungkin memperkenalkan kependaman tambahan.

Kesimpulan

Corak Objek Aktif ialah alat yang berkuasa untuk mengurus operasi tak segerak dalam persekitaran berbilang benang. Dengan memisahkan penggunaan kaedah daripada pelaksanaan, ia memastikan tindak balas yang lebih baik, kebolehskalaan dan pangkalan kod yang lebih bersih. Walaupun ia datang dengan beberapa kerumitan dan potensi overhed prestasi, faedahnya menjadikannya pilihan yang sangat baik untuk senario yang memerlukan keselarasan tinggi dan pelaksanaan yang boleh diramal. Walau bagaimanapun, penggunaannya bergantung pada masalah khusus yang dihadapi. Seperti kebanyakan corak dan algoritma, tiada penyelesaian satu saiz yang sesuai untuk semua.

Rujukan

Wikipedia - Objek Aktif

Atas ialah kandungan terperinci Corak Concurrency: Objek Aktif. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!