Java Nio dan Asynchronous I/O sesuai untuk senario aplikasi konkurensi tinggi dan tinggi. 1. NIO melaksanakan I/O yang tidak menyekat melalui saluran, buffer dan pemilih, menyokong pengurusan benang tunggal pelbagai sambungan, dan sesuai untuk pelayan rangkaian serentak yang tinggi. 2. Asynchronous I/O (AIO) didasarkan pada panggilan balik atau masa depan, benar-benar melaksanakan operasi tak segerak, sesuai untuk latensi rendah dan perkhidmatan yang tinggi; 3. Fail I/O dan Pemetaan Memori Gunakan Nio FileChannel, dan perkhidmatan rangkaian Concurrency tinggi lebih suka pemilih NIO, manakala AIO boleh dianggap keperluan asynchronous; 4. Dalam pembangunan sebenar, adalah disyorkan untuk menggunakan rangka kerja matang seperti Netty untuk mengelakkan kerumitan dan perbezaan platform yang mendasari. Ringkasan: NIO harus digunakan apabila membina aplikasi yang perlu mengendalikan ribuan sambungan dengan cekap, tetapi persekitaran pengeluaran harus diberikan keutamaan untuk menggunakan rangka kerja berprestasi tinggi yang dibungkus.

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 berat. 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 pecahan praktikal Java Nio dan I/O Asynchronous, dengan corak penggunaan dunia dan contoh kod.

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

Java Nio, diperkenalkan dalam Java 1.4, revolusi sekitar tiga komponen teras: saluran , penampan , dan pemilih .

Saluran dan buffer

Tidak seperti sungai dalam I/O tradisional, yang merupakan satu arah, saluran adalah bidedirectional dan boleh membaca atau menulis kepada penampan .

Jenis Saluran Biasa:

• FileChannel - Untuk operasi fail
• SocketChannel , ServerSocketChannel - Untuk rangkaian TCP
• DatagramChannel - untuk UDP

Buffer (seperti ByteBuffer , CharBuffer ) memegang data yang dibaca dari atau ditulis ke saluran.

Contoh: Membaca fail menggunakan FileChannel

 cuba (file randomAccessFile = baru RandomAccessFile ("data.txt", "r");
     Saluran fileChannel = file.getChannel ()) {

    ByteBuffer buffer = byteBuffer.allocate (1024);
    int byteSread = channel.read (buffer);

    Semasa (Bytesread! = -1) {
        buffer.flip (); // Sediakan penampan untuk membaca
        sementara (buffer.hasremaining ()) {
            System.out.print ((char) buffer.get ());
        }
        buffer.clear (); // Sediakan penampan untuk menulis lagi
        bytesRead = channel.read (buffer);
    }
} menangkap (ioException e) {
    e.printstackTrace ();
}

Tidak menyekat I/O dengan pemilih

Pemilih membenarkan benang tunggal untuk menguruskan pelbagai saluran. Ini adalah kunci untuk pelayan rangkaian berskala.

Bagaimana ia berfungsi:

• Daftar SelectableChannel S (seperti SocketChannel ) dengan Selector
• Gunakan select() untuk menunggu acara (misalnya, data siap dibaca)
• Proses hanya saluran yang siap

Contoh: Pelayan echo mudah menggunakan pemilih

 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 ();
    Iterator <pecstionKey> keyIterator = keys.iterator ();

    sementara (keyIterator.HasNext ()) {
        Pemilihan kunci = keyIterator.Next ();
        keyIterator.remove ();

        jika (key.isAcceptable ()) {
            Klien socketchannel = serverChannel.Accept ();
            client.configureBlocking (false);
            client.register (selector, pilihanKey.op_read);
        } else if (key.isReadable ()) {
            Socketchannel client = (socketetchannel) key.channel ();
            ByteBuffer buffer = byteBuffer.allocate (1024);
            int byteSread = client.read (buffer);

            jika (bytesread> 0) {
                buffer.flip ();
                client.write (buffer); // echo kembali
            } else if (bytesread == -1) {
                client.close ();
            }
        }
    }
}

Model ini membolehkan pengendalian ribuan sambungan dengan hanya beberapa benang.

2. Asynchronous I/O (AIO) di Jawa: java.nio.channels.Asynchronous API

Pengenalan dalam Java 7, I/O Asynchronous (juga dikenali sebagai NIO.2) menyediakan operasi yang benar -benar tidak segerak menggunakan panggilan balik atau niaga hadapan.

Antara muka utama:

• AsynchronousSocketChannel
• AsynchronousServerSocketChannel
• AsynchronousFileChannel

Operasi mengembalikan Future atau menerima CompletionHandler .

Menggunakan niaga hadapan (mudah, gaya menyekat)

 AsynchronousSocketchAnnel client = asynchronousSocketchAnnel.Open ();
client.Connect (baru inetocketAddress ("localhost", 8080)). get ();

ByteBuffer buffer = byteBuffer.allocate (1024);
Masa depan <teger> result = client.read (buffer);
Integer bytesread = result.get (); // blok sehingga selesai
buffer.flip ();

Menggunakan Penyempurnaan (benar -benar tidak segerak)

 client.read (buffer, null, baru penyempurnaan <integer, object> () {
    @Override
    void awam selesai (hasil integer, lampiran objek) {
        jika (hasil> 0) {
            buffer.flip ();
            // Data proses
            System.out.println ("Baca" Hasil "bait");
        }
        // Teruskan membaca atau tutup
    }

    @Override
    void awam gagal (dibuang exc, lampiran objek) {
        System.err.println ("Baca gagal:" exc);
    }
});

Model berasaskan panggilan balik ini mengelakkan menyekat benang sepenuhnya-ideal untuk sistem tinggi.

3. Bila Menggunakan Nio vs AIO vs Tradisional I/O

?? Nota: AIO tidak selalunya lebih cepat. Pada Linux, ia dibina di Epoll tetapi dengan batasan. Banyak rangka kerja berprestasi tinggi (seperti Netty) menggunakan NIO dengan corak reaktor dan bukannya AIO kerana sokongan dan kematangan silang platform yang lebih baik.

4. Amalan terbaik dan perangkap biasa

• Sentiasa flip () dan jelas () buffer - lupa untuk flip selepas menulis ke penampan adalah pepijat biasa.
• Gunakan penampan langsung dengan berhati-hati - ByteBuffer.allocateDirect() mengelakkan menyalin tetapi menggunakan memori luar dan mahal untuk dicipta.
• Mengendalikan Bacaan Separa/Menulis - Hanya kerana anda meminta 1024 bait tidak bermakna anda akan mendapatkannya sekaligus.
• Elakkan lebih banyak AIO - pada beberapa platform (terutamanya JVM atau Windows yang lebih tua), AIO mungkin tidak dilakukan seperti yang diharapkan.
• Rangka kerja yang lebih suka - untuk aplikasi pengeluaran, pertimbangkan untuk menggunakan Netty , Vert.x , atau Grizzly dan bukannya NIO/AIO mentah.

Ringkasan

Java Nio dan Asynchronous I/O memberi anda kawalan halus ke atas operasi I/O, membolehkan aplikasi berskala dan cekap. Walaupun NIO dengan Selector digunakan secara meluas dan stabil, AIO menawarkan model async yang lebih bersih tetapi dengan nuansa khusus platform.

Untuk pembelajaran: Mulakan dengan NIO dan Selector . Untuk pengeluaran: Pertimbangkan menggunakan rangka kerja yang abstrak kerumitan ini.

Pada asasnya, jika anda membina sesuatu yang perlu mengendalikan beratus -ratus atau beribu -ribu sambungan dengan cekap, NIO adalah cara untuk pergi -hanya tidak menggulung rangka kerja anda sendiri melainkan jika anda benar -benar perlu.

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