Java Nio dan Asynchronous I/O sesuai untuk kesesuaian tinggi dan senario I/O yang intensif. 1. NIO didasarkan pada buffer, saluran dan pemilih, dan menyokong I/O yang tidak menyekat dan pengurusan tunggal yang pelbagai sambungan; 2. AIO benar -benar tidak segerak melalui saluran tak segerak dan panggilan balik atau masa depan, dan disiapkan oleh pemberitahuan sistem operasi; 3. NIO stabil di seluruh platform dan sesuai untuk perkhidmatan kesesuaian yang paling tinggi. AIO melakukan lebih baik tetapi kompleks pada platform tertentu; 4. Perhatikan pengurusan penampan, keselamatan benang, pelepasan sumber dan masalah tekanan belakang apabila menggunakannya. Adalah disyorkan untuk memberi keutamaan untuk menggunakan kerangka matang seperti Netty untuk mengurangkan kerumitan, dan akhirnya memilih model yang sesuai berdasarkan keperluan prestasi dan ciri -ciri platform.

Java Nio (I/O baru) dan I/O Asynchronous adalah alat yang berkuasa untuk membina aplikasi berprestasi tinggi, berskala-terutamanya apabila berurusan dengan sejumlah besar sambungan serentak atau operasi I/O terikat. Walaupun Java I/O tradisional menghalang dan berasaskan benang-per-sambungan, NIO dan rakan sejawatnya yang tidak segerak menawarkan model yang tidak menyekat dan didorong oleh peristiwa yang menggunakan sumber sistem yang lebih baik.

Berikut adalah panduan praktikal untuk memahami dan menggunakan Java Nio dan I/O Asynchronous dengan berkesan.

1. Memahami Java Nio: Buffer, Saluran, dan Pemilih

Java Nio, yang diperkenalkan di Java 1.4, beralih dari I/O berasaskan aliran ke model penimbal dan berasaskan saluran. Komponen teras adalah:

• Buffer : Bekas data (seperti ByteBuffer , CharBuffer ) yang memegang data untuk dibaca dari atau ditulis kepada.
• Saluran : Sambungan ke sumber I/O (fail, soket) yang boleh membaca dan menulis data kepada penampan. Tidak seperti sungai, saluran adalah bidedirectional.
• Pemilih : Benarkan satu thread untuk memantau pelbagai saluran untuk acara (contohnya, data siap dibaca).

Konsep utama dalam amalan

• Mod tidak menyekat : Saluran boleh dikonfigurasikan untuk beroperasi dalam mod tidak menyekat. Apabila tiada data tersedia, mereka kembali dengan segera dan bukannya menyekat.
• Multiplexing dengan pemilih : Satu benang boleh menguruskan banyak saluran menggunakan Selector . Ini sesuai untuk pelayan rangkaian berskala.

 Pemilih pemilih = selector.Open ();
Serverocketchannel serverChannel = serversocketchannel.open ();
serverChannel.Bind (baru inetocketAddress (8080));
serverChannel.ConfigureBlocking (false);
serverChannel.Register (pemilih, pilihanSey.OP_ACCEPT);

sementara (benar) {
    pemilih.Select (); // blok sehingga sekurang -kurangnya satu saluran sudah siap
    Tetapkan <pecessKey> kekunci = selector.selectedKeys ();
    untuk (Kunci Pilihan Kekunci: Kekunci) {
        jika (key.isAcceptable ()) {
            // terima sambungan baru
        } else if (key.isReadable ()) {
            // Baca data dari saluran
        }
    }
    kunci.clear ();
}

Model ini membolehkan satu benang mengendalikan beratus-ratus atau ribuan sambungan-hebat untuk pelayan sembang, proksi, atau sistem data masa nyata.

2. Asynchronous I/O (AIO) dengan java.nio.channels.asynchronous saluran

Asynchronous I/O, yang diperkenalkan di Java 7 (NIO.2), mengambil langkah lebih jauh. Ia membolehkan operasi disiapkan di latar belakang, memberitahu permohonan anda apabila dilakukan -sama ada melalui panggilan balik atau niaga hadapan.

Antara muka utama:

• AsynchronousSocketChannel
• AsynchronousServerSocketChannel
• AsynchronousFileChannel

Menggunakan AIO dengan Penyelesaian Penyelesaian

 AsynchronousServerCocketChannel Server = asynchronousServerCocketChannel.Open ();
server.bind (baru inetocketAddress (8080));

server.Accept (null, baru penyempurnaan <asynchronoussocketchannel, void> () {
    @Override
    void awam selesai (klien asynchronoussocketchannel, lampiran tidak sah) {
        // Terima sambungan seterusnya
        server.Accept (null, ini);

        // Baca dari pelanggan
        ByteBuffer buffer = byteBuffer.allocate (1024);
        client.read (buffer, null, baru penyempurnaan <integer, byteBuffer> () {
            @Override
            void awam selesai (hasil integer, byteBuffer buf) {
                jika (hasil> 0) {
                    buf.flip ();
                    // Data proses
                    client.write (buf, buf, baru penyelesaian <integer, byteBuffer> () {
                        @Override
                        void awam siap (hasil integer, penampan byteBuffer) {
                            buffer.compact ();
                        }
                        @Override
                        public void gagal (dibuang exc, bytebuffer buffer) {
                            cuba {client.close (); } menangkap (ioException e) {}
                        }
                    });
                }
            }
            @Override
            public void gagal (dibuang exc, byteBuffer buf) {
                cuba {client.close (); } menangkap (ioException e) {}
            }
        });
    }

    @Override
    void public gagal (dibuang exc, void lampiran) {
        // Mengendalikan ralat
    }
});

Pendekatan yang didorong oleh panggilan balik ini mengurangkan overhead benang dan sangat baik untuk aplikasi sensitif latency.

Menggunakan AIO dengan niaga hadapan

Anda juga boleh menggunakan API berasaskan Future untuk kes yang lebih mudah:

 AsynchronousSocketchAnnel client = asynchronousSocketchAnnel.Open ();
Masa depan <void> connectOp = client.connect (baru inetocketAddress ("localhost", 8080));
connectOp.get (); // tunggu sambungan

ByteBuffer buffer = byteBuffer.wrap ("hello" .getBytes ());
Masa Depan <Enteger> writeOp = client.write (buffer);
int byteswritten = writeOp.get ();

Niaga hadapan lebih mudah untuk membuat alasan tentang tetapi menyekat .get() , jadi mereka lebih baik digunakan dalam persekitaran terkawal.

3. Bila Menggunakan Nio vs AIO

Memilih antara NIO dan AIO bergantung pada kes penggunaan dan platform anda:

? Petua : Pada Linux, NIO dengan epoll sering lebih cepat dan lebih stabil daripada AIO. AIO mungkin tidak memberikan faedah yang signifikan melainkan anda menolak beban I/O yang melampau.

4. Perangkap biasa dan amalan terbaik

• Pengurusan Buffer : Sentiasa flip () selepas menulis kepada penampan dan padat () selepas membaca.
• Keselamatan Thread : Selector tidak selamat thread; biasanya diakses oleh satu thread penghantaran.
• Kebocoran sumber : Sentiasa menutup saluran dan kekunci deregister untuk mengelakkan kebocoran ingatan.
• Backpressure : Mengendalikan pengguna yang perlahan -jangan saluran banjir dengan data.
• Gunakan rangka kerja jika mungkin : Pertimbangkan Netty atau Undertow dan bukannya NIO/AIO mentah-mereka yang abstrak kerumitan dan diuji pertempuran.

Pemikiran terakhir

Java Nio dan Asynchronous I/O membuka pintu untuk membina aplikasi yang berskala dan cekap. Walaupun NIO memberi anda kawalan halus ke atas I/O yang tidak menyekat dengan pemilih, AIO menolak model Async lebih jauh dengan pemberitahuan penyelesaian peringkat OS.

Bagi kebanyakan pemaju, bermula dengan konsep NIO (terutamanya melalui rangka kerja) lebih praktikal. AIO berkuasa tetapi kurang digunakan kerana ketidakkonsistenan platform dan kerumitan.

Sama ada cara, memahami model -model ini membantu anda membuat keputusan seni bina yang lebih baik apabila prestasi penting.

Pada asasnya, ketahui alat anda -dan bila membiarkan rangka kerja orang lain mengendalikan pengangkat berat.

Atas ialah kandungan terperinci Panduan untuk Java Nio dan I/O Asynchronous. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!