java中的ConcurrentMap接口

ConcurrentMap 是一个接口，它是Java集合框架的成员，在JDK 1.5中引入，表示一个能够处理并发访问的地图，而不影响地图中条目的一致性。ConcurrentMap接口存在于 java.util.concurrent 包中。除了从SuperInterface即java.util.Map继承的方法外，它还提供了一些额外的方法。它继承了嵌套接口Map.Entry<K, V>。

HashMap的操作是不同步的，而Hashtable提供了同步性。尽管Hashtable是一个线程安全的，但它的效率并不高。为了解决这个问题，Java集合框架在Java 1.5中引入了 ConcurrentMap

ConcurrentMap的层次结构

声明 。

public interface ConcurrentMap<K,V> extends Map<K,V>

这里， K 是key Object的类型， V 是value Object的类型。

• 它扩展了Java中的Map接口。
• ConcurrentNavigableMap<K,V>是子接口。
• ConcurrentMap由ConcurrentHashMap、 ConcurrentSkipListMap 类实现。
• ConcurrentMap被称为同步Map。

实现的类

由于它属于 java.util.concurrent 包，所以我们必须用以下方式导入

import java.util.concurrent.ConcurrentMap
                or
import java.util.concurrent.*

ConcurrentMap有两个实现类，即 ConcurrentSkipListMap 和 ConcurrentHashMap。 ConcurrentSkipListMap是ConcurrentNavigableMap接口的一个可扩展的实现，它扩展了ConcurrentMap接口。ConcurrentSkipListMap中的键是按自然顺序排序的，或者在构造对象时使用比较器。ConcurrentSkipListMap的插入、删除和搜索操作的预期时间成本为 log（n） 。它是一个线程安全的类，因此，所有的基本操作都可以并发地完成。

语法

// ConcurrentMap implementation by ConcurrentHashMap
CocurrentMap<K, V> numbers = new ConcurrentHashMap<K, V>();

// ConcurrentMap implementation by ConcurrentSkipListMap
ConcurrentMap< ? , ? > objectName = new ConcurrentSkipListMap< ? , ? >();

例如：

// Java Program to illustrate methods
// of ConcurrentMap interface
import java.util.concurrent.*;
  
class ConcurrentMapDemo {
  
    public static void main(String[] args)
    {
        // Since ConcurrentMap is an interface,
        // we create instance using ConcurrentHashMap
        ConcurrentMap<Integer, String> m = new ConcurrentHashMap<Integer, String>();
        m.put(100, "Geeks");
        m.put(101, "For");
        m.put(102, "Geeks");
  
        // Here we cant add Hello because 101 key
        // is already present
        m.putIfAbsent(101, "Hello");
  
        // We can remove entry because 101 key
        // is associated with For value
        m.remove(101, "For");
  
        // Now we can add Hello
        m.putIfAbsent(101, "Hello");
  
        // We can replace Hello with For
        m.replace(101, "Hello", "For");
        System.out.println("Map contents : " + m);
    }
}

输出

Map contents : {100=Geeks, 101=For, 102=Geeks}

基本方法

1.添加元素

ConcurrentSkipListMap的put()方法是Java中的一个内置函数，它将指定的值与该地图中的指定键联系起来。如果该地图以前包含了该键的映射，那么旧的值将被替换。

// Java Program to demonstrate adding
// elements
  
import java.util.concurrent.*;
  
class AddingElementsExample {
    public static void main(String[] args)
    {
        // Instantiate an object
        // Since ConcurrentMap
        // is an interface so We use
        // ConcurrentSkipListMap
        ConcurrentMap<Integer, Integer> mpp = new ConcurrentSkipListMap<Integer, Integer>();
  
        // Adding elements to this map
          // using put() method
        for (int i = 1; i <= 5; i++)
            mpp.put(i, i);
  
        // Print map to the console
        System.out.println("After put(): " + mpp);
    }
}

输出

After put(): {1=1, 2=2, 3=3, 4=4, 5=5}

2.移除元素

ConcurrentSkipListMap的remove()方法是Java中的一个内置函数，可以从该地图中移除指定键的映射。如果没有该特定键的映射，该方法返回null。执行该方法后，地图的大小会减少。

// Java Program to demonstrate removing
// elements
  
import java.util.concurrent.*;
  
class RemovingElementsExample {
    public static void main(String[] args)
    {
        // Instantiate an object
        // Since ConcurrentMap
        // is an interface so We use
        // ConcurrentSkipListMap
        ConcurrentMap<Integer, Integer> mpp = new ConcurrentSkipListMap<Integer, Integer>();
  
        // Adding elements to this map
        // using put method
        for (int i = 1; i <= 5; i++)
            mpp.put(i, i);
  
        // remove() mapping associated
        // with key 1
        mpp.remove(1);
  
        System.out.println("After remove(): " + mpp);
    }
}

输出

After remove(): {2=2, 3=3, 4=4, 5=5}

3.访问元素

我们可以使用get()方法访问ConcurrentSkipListMap的元素，下面给出了这个例子。

// Java Program to demonstrate accessing
// elements
  
import java.util.concurrent.*;
  
class AccessingElementsExample {
  
    public static void main(String[] args)
    {
  
        // Instantiate an object
        // Since ConcurrentMap
        // is an interface so We use
        // ConcurrentSkipListMap
        ConcurrentMap<Integer, String> chm = new ConcurrentSkipListMap<Integer, String>();
  
        // insert mappings using put method
        chm.put(100, "Geeks");
        chm.put(101, "for");
        chm.put(102, "Geeks");
        chm.put(103, "Contribute");
  
        // Displaying the HashMap
        System.out.println("The Mappings are: ");
        System.out.println(chm);
  
        // Display the value of 100
        System.out.println("The Value associated to "
                           + "100 is : " + chm.get(100));
  
        // Getting the value of 103
        System.out.println("The Value associated to "
                           + "103 is : " + chm.get(103));
    }
}

输出

The Mappings are: 
{100=Geeks, 101=for, 102=Geeks, 103=Contribute}
The Value associated to 100 is : Geeks
The Value associated to 103 is : Contribute

4.遍历

我们可以使用Iterator接口来遍历集合框架的任何结构。由于迭代器只处理一种类型的数据，我们使用Entry< ?, ? >来将两种不同的类型解析成一种兼容的格式。然后使用next()方法，我们打印ConcurrentSkipListMap的元素。

import java.util.concurrent.*;
import java.util.*;
  
public class TraversingExample {
  
    public static void main(String[] args)
    {
  
        // Instantiate an object
        // Since ConcurrentMap
        // is an interface so We use
        // ConcurrentSkipListMap
        ConcurrentMap<Integer, String> chmap = new ConcurrentSkipListMap<Integer, String>();
  
        // Add elements using put()
        chmap.put(8, "Third");
        chmap.put(6, "Second");
        chmap.put(3, "First");
        chmap.put(11, "Fourth");
  
        // Create an Iterator over the
        // ConcurrentSkipListMap
        Iterator<ConcurrentSkipListMap
                     .Entry<Integer, String> > itr
            = chmap.entrySet().iterator();
  
        // The hasNext() method is used to check if there is
        // a next element The next() method is used to
        // retrieve the next element
        while (itr.hasNext()) {
            ConcurrentSkipListMap
                .Entry<Integer, String> entry
                = itr.next();
            System.out.println("Key = " + entry.getKey()
                               + ", Value = "
                               + entry.getValue());
        }
    }
}

输出

Key = 3, Value = First
Key = 6, Value = Second
Key = 8, Value = Third
Key = 11, Value = Fourth

ConcurrentMap的方法

• K – 地图中键的类型。
• V – 在地图中映射的值的类型。

从java.util.Map接口继承的方法

参考资料: https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/ConcurrentMap.html