Cara menggunakan fungsi ConcurrentHashMap untuk operasi pemetaan serentak dalam Java

Dengan percambahan pemproses berbilang teras, pengaturcaraan serentak dalam aplikasi komputer telah menjadi kemahiran yang semakin penting. Di Jawa, ConcurrentHashMap ialah struktur data jadual pemetaan serentak yang cekap yang boleh memenuhi keperluan akses serentak sambil memastikan keselamatan benang. Artikel ini akan memperkenalkan cara menggunakan fungsi ConcurrentHashMap dalam Java untuk melaksanakan operasi pemetaan serentak.

ConcurrentHashMap ialah pelaksanaan jadual cincang selamat benang yang diperkenalkan di Java 5. Berbanding dengan Hashtable dan SynchronizedMap, ia mempunyai prestasi konkurensi yang lebih baik. Sama seperti Hashtable dan SynchronizedMap, ConcurrentHashMap juga merupakan jadual pemetaan pasangan nilai kunci, tetapi ia menggunakan teknologi kunci tersegmen untuk mengurangkan persaingan kunci.

Menggunakan ConcurrentHashMap di Java adalah mudah. Mula-mula, anda perlu mengimport pakej java.util.concurrent.ConcurrentHashMap, dan kemudian mencipta objek ConcurrentHashMap.

import java.util.concurrent.ConcurrentHashMap;

ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();

Dalam kod di atas, kami mencipta objek ConcurrentHashMap untuk menyimpan pasangan nilai kunci, dengan jenis kunci ialah String dan jenis nilai ialah Integer.

Fungsi ConcurrentHashMap yang biasa digunakan
Berikut ialah fungsi yang biasa digunakan dalam ConcurrentHashMap dan cara menggunakannya.

1. put()
   Menambah pasangan nilai kunci yang ditentukan pada ConcurrentHashMap. Jika kunci yang ditentukan sudah wujud, nilai yang sepadan dikemas kini dan nilai lama dikembalikan. Jika kunci yang ditentukan tidak wujud, pasangan nilai kunci baharu ditambah dan null dikembalikan.

   Integer oldValue = map.put("a", 1); // 添加键值对a=1，返回null
   Integer value = map.put("b", 2); // 添加键值对b=2，返回null
   Integer newValue = map.put("a", 3); // 更新键值对a=3，返回旧值1

2. get()
   Dapatkan nilai yang sepadan dengan kunci yang ditentukan. Jika kunci tidak wujud, mengembalikan null.

   Integer value = map.get("a"); // 获取键a对应的值3

3. move()
   Padamkan pasangan nilai kunci yang ditentukan. Jika kunci tidak wujud, mengembalikan null.

   Integer value = map.remove("a"); // 删除键a对应的键值对，返回值3

4. replace()
   Ganti nilai yang sepadan dengan kunci yang ditentukan. Jika kunci tidak wujud, mengembalikan null.

   Integer oldValue = map.replace("b", 4); // 替换键b对应的值为4，返回旧值2

5. putIfAbsent()
   Jika kunci yang ditentukan tidak wujud, tambahkan pasangan nilai kunci baharu dan kembalikan nol. Jika kunci yang ditentukan sudah wujud, nilai yang sepadan dikembalikan.

   Integer oldValue = map.putIfAbsent("a", 5); // putIfAbsent会判断键a是否存在，因为键a已经存在于ConcurrentHashMap中，此次添加操作不会执行，返回a对应的旧值3
   Integer value = map.putIfAbsent("c", 6); // putIfAbsent会判断键c是否存在，因为键c不存在于ConcurrentHashMap中，此次添加键值对c=6操作会执行，返回null

6. size()
   Dapatkan bilangan pasangan nilai kunci dalam ConcurrentHashMap.

   int size = map.size(); // 获取ConcurrentHashMap中键值对的数量

7. clear()
   Padamkan semua pasangan nilai kunci dalam ConcurrentHashMap.

   map.clear(); // 删除ConcurrentHashMap中的所有键值对

Contoh kod
Berikut ialah contoh mudah yang menunjukkan cara menggunakan fungsi ConcurrentHashMap untuk operasi pemetaan serentak. Dalam contoh ini, kami akan memulakan berbilang urutan untuk menambah pasangan nilai kunci pada ConcurrentHashMap dan mengakses pasangan nilai kunci secara serentak.

import java.util.concurrent.ConcurrentHashMap;

public class ConcurrentHashMapDemo {
    public static void main(String[] args) throws InterruptedException {
        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();

        // 添加键值对的线程
        Thread addThread = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                map.put(String.valueOf(i), i);
            }
        });

        // 访问键值对的线程
        Thread visitThread = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                Integer value = map.get(String.valueOf(i));
                System.out.println(Thread.currentThread().getName() + " " + value);
            }
        });

        addThread.start();
        visitThread.start();

        addThread.join();
        visitThread.join();
    }
}

Dalam contoh ini, kita memulakan dua utas, satu utas digunakan untuk menambah pasangan nilai kunci pada ConcurrentHashMap dan urutan satu lagi digunakan untuk mengakses pasangan nilai kunci. Dalam urutan akses, kami menggunakan fungsi get() ConcurrentHashMap untuk mendapatkan nilai pasangan nilai kunci.

Hasil keluaran adalah seperti berikut:

Thread-1 0
Thread-1 1
Thread-1 2
Thread-1 3
Thread-1 4
.
.
.
Thread-1 97
Thread-1 98
Thread-1 99

Dapat dilihat bahawa benang tambah dan benang akses berjalan pada masa yang sama, dan tidak akan ada persaingan antara benang. ConcurrentHashMap memastikan keselamatan benang dan prestasi serentak yang tinggi.

Ringkasan
Artikel ini memperkenalkan cara menggunakan fungsi ConcurrentHashMap dalam Java untuk melaksanakan operasi pemetaan serentak. Dengan menggunakan ConcurrentHashMap, kami boleh meningkatkan prestasi serentak program dan memastikan keselamatan benang dalam senario berbilang benang. Sama ada anda sedang membangunkan aplikasi rangkaian konkurensi tinggi atau sistem teragih yang memproses data berskala besar, ConcurrentHashMap ialah alat yang sangat praktikal.

Atas ialah kandungan terperinci Cara menggunakan fungsi ConcurrentHashMap untuk operasi pemetaan serentak dalam Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!