Memahami `serentakhashmap` dan kelebihannya di Jawa

ConcurrentHashMap adalah pelaksanaan peta yang selamat di Java untuk senario concurrency yang tinggi. Kelebihan terasnya terletak pada pelaksanaan akses serentak berprestasi tinggi melalui penguncian halus dan operasi bacaan tanpa kunci. 1. Ia tidak menggunakan kunci jadual penuh. Versi awal menggunakan kunci tersegmentasi. Dari Java 8, ia menggunakan operasi CAS dan mengunci satu baldi. Ia hanya mengunci baldi tertentu atau nod pokok merah hitam apabila perlu untuk mengelakkan penyekatan global. 2. Pelbagai benang boleh membaca pasangan nilai utama yang berbeza pada masa yang sama. Operasi bacaan tidak mempunyai kunci dan memastikan penglihatan berdasarkan tidak menentu. Operasi tulis hanya mengunci baldi yang sepadan, yang dengan ketara meningkatkan throughput konkurensi. 3. Menyediakan Iterator Konsistensi yang lemah. Konsepsi ConcurrentModification tidak akan dibuang semasa traversal, tetapi tidak dijamin untuk mencerminkan pengubahsuaian terkini. 4. Menyokong operasi komposit atom seperti Putifabsent, Computeifabsent, Gabungan, dan lain -lain, untuk mengelakkan keadaan perlumbaan "cek dan kemudian beroperasi" dan tiada penyegerakan luaran diperlukan. 5. Ia mempunyai skalabilitas yang baik dalam persekitaran yang tinggi, terutamanya yang sesuai untuk senario di mana lebih banyak bacaan, kurang menulis, seperti cache, kaunter, dan lain-lain. Oleh itu, apabila pelbagai benang memerlukan membaca dan menulis secara bersamaan dan meneruskan keseimbangan dan keseimbangan keselamatan,

Java's ConcurrentHashMap adalah pelaksanaan thread yang selamat dari antara muka Map yang direka untuk akses serentak berprestasi tinggi dalam persekitaran berbilang threaded. Tidak seperti peta yang disegerakkan tradisional, ia membolehkan pelbagai benang membaca dan menulis secara serentak tanpa menyekat satu sama lain yang tidak perlu. Mari kita pecahkan bagaimana ia berfungsi dan mengapa ia adalah pilihan pilihan dalam pengaturcaraan serentak.

Bagaimana ConcurrentHashMap berfungsi

ConcurrentHashMap mencapai keselamatan benang tanpa mengunci keseluruhan peta. Daripada menyegerakkan setiap kaedah (seperti Hashtable atau Collections.synchronizedMap() ), ia menggunakan teknik yang dipanggil Lock Striping .

Dalam versi awal Java (sebelum Java 8), peta dibahagikan kepada segmen - bahagian jadual hash bebas, masing -masing dengan kunci sendiri. Ini membolehkan beberapa benang beroperasi pada segmen yang berbeza secara serentak.

Bermula dengan Java 8 , pelaksanaannya berubah dengan ketara:

• Ia menggunakan pelbagai objek Node (serupa dengan HashMap ).
• Apabila baldi menjadi terlalu ramai, ia ditukar menjadi pokok seimbang (pokok merah hitam) untuk meningkatkan prestasi terburuk dari O (n) ke O (log n).
• Daripada kunci peringkat segmen, ia menggunakan operasi CAS (membandingkan-dan-swap) dan synchronized pada baldi individu apabila perlu.

Ini bermakna hanya baldi tertentu (atau pokok) yang diubahsuai dikunci - bukan keseluruhan peta - yang membolehkan kesesuaian yang lebih tinggi.

Kelebihan Utama ConcurrentHashMap

1. Prestasi yang lebih baik di bawah pertengkaran

Kerana hanya sebahagian daripada peta yang dikunci semasa menulis, pelbagai benang boleh mengakses bahagian -bahagian yang berbeza dari peta.

Contohnya:

• Thread 1 mengemas kini kekunci "A" → Locks Bucket untuk "A"
• Thread 2 Updates Key "B" → Locks Bucket for "B" (baldi yang berbeza)
• Kedua -dua operasi diteruskan selari

Ini jauh lebih cekap daripada synchronizedMap , di mana satu benang menghalang semua yang lain.

2. Thread-selamat tanpa penyegerakan penuh

Anda mendapat keselamatan benang tanpa penalti prestasi menyegerakkan keseluruhan struktur data. Semua operasi (meletakkan, mendapatkan, mengeluarkan, dan lain -lain) direka untuk selamat dalam persekitaran serentak.

 ConcurrentHashMap <String, Integer> Map = new ConcurrentHashMap <> ();
Map.put ("Key1", 100);
int value = map.get ("key1"); // selamat tanpa penyegerakan luaran

3. Peralihan selamat tanpa ConcurrentModificationException

Tidak seperti HashMap , yang melemparkan ConcurrentModificationException jika diubahsuai semasa lelaran, ConcurrentHashMap memberikan lelaran yang konsisten yang lemah .

Mereka mencerminkan keadaan peta pada satu ketika dan tidak membuang pengecualian jika peta diubahsuai semasa Traversal.

 untuk (Map.Entry <String, Integer> entry: Map.EntrySet ()) {
    System.out.println (entry.getKey () ":" entry.getValue ());
}
// Tidak akan membuang ConcurrentModificationException walaupun benang lain mengubah suai peta

⚠uti bagaimanapun, perubahan yang dibuat selepas pengarah dicipta mungkin atau mungkin tidak dapat dilihat.

4. Operasi atom untuk corak biasa

Ia menyediakan kaedah utiliti yang melaksanakan operasi kompaun secara atom, yang penting dalam kod serentak:

• putIfAbsent(key, value) - hanya meletakkan jika kunci tidak wujud
• computeIfPresent(key, remappingFunction)
• computeIfAbsent(key, mappingFunction)
• merge(key, value, remappingFunction)

Ini menghapuskan keperluan untuk penyegerakan luaran apabila melakukan operasi check-then-act.

 // inisialisasi malas benang
Map.comPuteifabSent ("ENHURTHEYKEY", K -> LOADEXPensivEvalue ());

Tanpa computeIfAbsent , anda perlu menyegerakkan corak ini secara manual untuk mengelakkan keadaan kaum.

5. Skalabiliti dalam persekitaran tinggi

Oleh kerana penguncian halus dan tidak menyekat operasi membaca, skala ConcurrentHashMap dengan baik dengan peningkatan jumlah benang-terutamanya apabila dibaca lebih kerap daripada menulis (senario biasa).

Baca operasi (seperti get ) adalah bebas kunci, menggunakan bacaan yang tidak menentu untuk memastikan penglihatan.

Bila Menggunakan ConcurrentHashMap

Gunakan ConcurrentHashMap ketika:

• Pelbagai benang sedang membaca dan menulis ke peta yang dikongsi
• Anda memerlukan throughput yang tinggi dan perbalahan yang rendah
• Anda mahu mengelakkan penyegerakan manual
• Anda membina cache, pendaftaran, atau kaunter dalam aplikasi pelbagai threaded

Elakkan ketika:

• Semua operasi mesti diselaraskan secara global (jarang berlaku)
• Anda memerlukan konsistensi yang kuat di pelbagai operasi (anda mungkin memerlukan penguncian peringkat lebih tinggi)

Ringkasan

ConcurrentHashMap menyerang keseimbangan yang besar antara keselamatan dan prestasi benang. Dengan meminimumkan mengunci dan menyokong operasi kompaun atom, ia sesuai untuk aplikasi serentak berskala.

Ia bukan hanya "hashmap yang selamat benang"-ia adalah struktur data yang dioptimumkan dengan teliti yang dibina untuk cabaran konvensional dunia sebenar.

Pada asasnya, jika anda menggunakan peta dalam konteks berbilang threaded, ConcurrentHashMap harus menjadi pilihan lalai anda melainkan anda mempunyai alasan yang sangat spesifik untuk tidak.

Atas ialah kandungan terperinci Memahami `serentakhashmap` dan kelebihannya di Jawa. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!