Bagaimana cara menggunakan penyelesaian yang boleh diselesaikan untuk memastikan perintah permintaan antara muka batch dan memproses hasilnya dengan cekap?

Pengaturcaraan Serentak Java: Gunakan penyelesaian yang boleh diselesaikan untuk mengendalikan permintaan antara muka yang cekap dan teratur

Akses serentak yang tinggi ke antara muka pihak ketiga dapat meningkatkan kecekapan pemprosesan data dengan ketara, tetapi jika perintah pelaksanaan thread tidak dikawal, hasil akhir mungkin tidak sepadan dengan perintah data asal, mengakibatkan kesilapan pemprosesan berikutnya. Artikel ini memperkenalkan cara menggunakan Java's CompletableFuture untuk memastikan pemprosesan teratur permintaan antara muka dan menghasilkan persekitaran pelbagai threaded.

Masalah: Gunakan CompletableFuture.runAsync secara langsung untuk membuat panggilan tak segerak. Oleh kerana perintah pelaksanaan thread yang tidak dapat diramalkan, hasil yang dikembalikan tidak konsisten dengan urutan senarai data asal. CompletableFuture.allOf hanya dapat menjamin penyempurnaan semua tugas, dan perintah itu tidak dapat dijamin.

Penyelesaian: Gunakan CompletableFuture.supplyAsync , yang mengembalikan hasilnya. Simpan hasil pengembalian setiap tugas tak segerak dalam CompletableFuture<string></string> Dalam senarai, selepas semua tugas selesai, hasilnya dikumpulkan dalam urutan asal melalui stream().map(CompletableFuture::join).collect(Collectors.toList()) .

Contoh kod yang lebih baik:

 public static void main (string [] args) {
    Senarai<string> datalist = arrayList baru  (); // Senarai Data Asal // ... Inisialisasi DataList ...

    Executorservice executorservice = threadpoolexecutor baru (
            10, // CorePoolSize
            20, // MaximumpoolSize
            60l, // Keepalivetime
            Timeunit.seconds,
            New LinkedBlockingQueue  (1024), // Workqueue
            baru threadpoolexecutor.callerrunspolicy () // handler
    );

    Senarai <completablefuture> > niaga hadapan = arraylist baru  ();
    untuk (data rentetan: datalist) {
        Futures.Add (siap bolehFuture.SupplyAsync (() -> {
            logger.info ("Data pemprosesan: {}", data);
            // hubungi antara muka pihak ketiga untuk memproses data
            // ... panggilan antara muka dan logik pemprosesan hasil ...
            mengembalikan data " - hasil yang diproses"; // hasil pemprosesan kembali}, executorservice));
    }

    Siap bolehFuture.allof (Futures.ToArray (baru boleh diselesaikan [0])). Thenrun (() -> {
        Senarai<string> hasil = niaga hadapan.stream ()
                .map (siap sedia :: bergabung)
                .kolect (collectors.tolist ());
        logger.info ("Semua tugas selesai. Keputusan: {}", json.tojsonstring (hasil));
        // hasil pemprosesan seterusnya}). Thenrun (() -> executOrservice.shutdown ());
}</string></completablefuture></string>

Kod yang lebih futures menggunakan CompletableFuture.supplyAsync . CompletableFuture.allOf stream().map(CompletableFuture::join).collect(Collectors.toList()) memastikan bahawa hasilnya dikumpulkan dalam urutan asal, dengan itu menyelesaikan masalah konkurensi mengikut urutan hasil. Kod ini juga menggunakan kolam thread tersuai untuk mengawal penggunaan sumber yang lebih baik.

Atas ialah kandungan terperinci Bagaimana cara menggunakan penyelesaian yang boleh diselesaikan untuk memastikan perintah permintaan antara muka batch dan memproses hasilnya dengan cekap?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!