Untuk membina pelayan Java TCP berprestasi tinggi, anda harus menggunakan kerangka Netty dan bukannya NIO asal; 1. Gunakan kumpulan gelung acara NETTY untuk menguruskan sambungan dan I/O; 2. Gunakan serialisasi yang cekap seperti protobuf untuk mengelakkan serialisasi asli Java; 3. Dayakan kawalan tekanan belakang untuk mengelakkan limpahan penampan melalui saluran.Swrtable (); 4. Menggunakan semula objek dan pooledByTebuFallocator untuk mengurangkan GC; 5. Konfigurasikan pilihan TCP seperti TCP_Nodelay dan saiz penampan yang sesuai untuk mengurangkan latensi; Menggabungkan ujian dan pemantauan tekanan untuk memastikan latency rendah dan throughput yang tinggi, dan akhirnya mencapai pemprosesan yang cekap puluhan ribu sambungan serentak.

Menulis pelayan TCP berprestasi tinggi di Java bukan sekadar menerima sambungan-ia secara efisien mengendalikan beribu-ribu pelanggan serentak dengan latency dan penggunaan sumber yang minimum. Walaupun Java menyediakan abstraksi pepejal untuk rangkaian, membina sesuatu yang berskala memerlukan pemahaman alat dan corak yang betul. Inilah cara melakukannya dengan betul.

Gunakan NIO dengan I/O yang tidak menyekat (java.nio)

Pelayan Java tradisional menggunakan java.net.ServerSocket dan model satu thread-per-klien tidak skala melebihi beberapa ratus sambungan kerana overhead benang. Penyelesaiannya? Java Nio (tidak menyekat I/O).

NIO membolehkan benang tunggal untuk menguruskan pelbagai sambungan melalui multiplexing menggunakan soket Selector , Channel , dan bukan blok.

Komponen utama:

• ServerSocketChannel - mendengar sambungan TCP yang masuk.
• SocketChannel - Mengendalikan pemindahan data untuk setiap pelanggan.
• Selector - memantau pelbagai saluran untuk acara (menerima, membaca, menulis) tanpa menyekat.
• SelectionKey - Mengesan keadaan saluran yang didaftarkan dengan pemilih.

Model ini membolehkan corak reaktor , di mana sebilangan kecil benang mengendalikan banyak sambungan.

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

Sekarang satu thread boleh gelung ke atas selector.select() , mengendalikan hanya acara siap.

Leverage Netty untuk Sistem Pengeluaran

Walaupun Raw Nio berkuasa, ia adalah tahap rendah dan rawan ralat. Bagi pelayan prestasi tinggi dunia, Netty adalah standard de facto.

Netty abstrak kerumitan NIO dan menyediakan:

• Kumpulan gelung acara (benang bos dan pekerja)
• Pengurusan penampan byte yang cekap
• Codec terbina dalam untuk protokol biasa
• Sokongan tekanan belakang
• Pengumpulan memori dan teknik sifar

Contoh pelayan Netty yang mudah:

 EventLoopGroup BossGroup = nioEventLoopGroup baru (1);
EventLoopGroup WorkerGroup = new NioEventLoOpGroup ();

Cuba {
    ServerBootstrap b = new ServeBootStrap ();
    B.Group (Bossgroup, Kerja Kerja)
     .CHANNEL (nioserversocketchannel.class)
     .ChildHandler (New ChannelInitializer <SocketchAnnel> () {
         @Override
         dilindungi void initchannel (socketchannel ch) {
             ch.pipeline (). AddLast (new YourRequestHandler ());
         }
     });

    Channelfuture f = b.bind (8080) .sync ();
    f.Channel (). CloseFuture (). Sync ();
} akhirnya {
    bossgroup.shutdowngraculy ();
    workerGroup.shutdowngraceLely ();
}

Netty secara automatik mengendalikan threading, i/o multiplexing, dan peristiwa kitaran hayat - semua dioptimumkan untuk tekanan dan tekanan GC yang rendah.

Optimalkan untuk prestasi: Petua Utama

Walaupun dengan rangka kerja yang betul, prestasi bergantung pada cara anda menggunakannya.

1. Tune thread saiz kolam

• Gunakan satu kumpulan bos (benang penerima) - biasanya 1 atau 2.
• Thread pekerja sepadan dengan teras CPU yang ada (atau sedikit lebih jika melakukan I/O menunggu).
• Elakkan membuat benang baru setiap tugas; Gunakan semula gelung acara Netty.

2. Gunakan serialisasi yang cekap

• Elakkan format berat seperti Serialization Java.
• Lebih suka protokol binari: Protobuf , Kryo , atau MessagePack .
• Penggunaan semula buffer apabila mungkin ( ByteBuf dalam netty).

3. Mengendalikan tekanan belakang

• Jangan biarkan pengeluar cepat mengatasi pengguna yang perlahan.
• Gunakan Kawalan Aliran: Jeda membaca dari soket apabila memproses barisan penuh.
• Channel.isWritable() membantu mengesan apabila penampan keluarnya dibebankan.

4. Minimize sampah

• Gunakan semula objek (misalnya, penampan decode, bekas mesej).
• Gunakan PooledByteBufAllocator Netty untuk mengurangkan GC.
• Elakkan pembalakan setiap mesej dalam pengeluaran.

5. Tetapkan pilihan TCP yang betul

 .ChildOption (channeloption.so_keepalive, benar)
.ChildOption (channeloption.tcp_nodelay, true) // matikan algoritma Nagle untuk latensi rendah
.ChildOption (channeloption.so_rcvbuf, 64 * 1024)
.ChildOption (channeloption.so_sndbuf, 64 * 1024)

TCP_NODELAY adalah kejam untuk aplikasi masa nyata-ia menghalang kelewatan paket kecil.

Memantau dan ujian tekanan

Pelayan berprestasi tinggi mesti disahkan:

• Gunakan alat seperti WRK , Jmeter , atau Gatling untuk ujian beban.
• Memantau:
  • Peratusan latensi (p99, p999)
  • Throughput (permintaan/saat)
  • GC berhenti
  • Perdebatan Thread
• Profil dengan Async-Profiler atau JFR (Java Flight Recorder) .

Malah hambatan kecil (seperti blok yang disegerakkan atau pembalakan) boleh prestasi tangki di bawah beban.

Pada asasnya, Raw Nio memberi anda kawalan, tetapi Netty memberi anda kelajuan, kestabilan, dan skalabilitas keluar dari kotak. Menggabungkannya dengan penalaan dan pemantauan pintar, dan anda mempunyai pelayan TCP yang boleh mengendalikan puluhan ribu sambungan dengan cekap.

Atas ialah kandungan terperinci Menulis pelayan TCP berprestasi tinggi di Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!