Java中ConcurrentHashMap是如何实现线程安全

concurrenthashmap是一个哈希表，支持检索的全并发和更新的高预期并发。此类遵循与 hashtable 相同的功能规范，并包含 hashtable 的所有方法。concurrenthashmap 位于 java.util.concurrent 包中。

语法：

public class concurrenthashmap<k,v>
extends abstractmap<k,v>
implements concurrentmap<k,v>, serializable

其中 k 指的是这个映射所维护的键的类型，v 指的是映射值的类型

concurrenthashmap 的需要：

• hashmap虽然有很多优点，但不能用于多线程，因为它不是线程安全的。
• 尽管 hashtable 被认为是线程安全的，但它也有一些缺点。例如，hashtable 需要锁定才能读取打开，即使它不影响对象。
• n hashmap，如果一个线程正在迭代一个对象，另一个线程试图访问同一个对象，它会抛出 concurrentmodificationexception，而并发 hashmap 不会抛出 concurrentmodificationexception。

如何使 concurrenthashmap 线程安全成为可能？

• java.util.concurrent.concurrenthashmap类通过将map划分为segment来实现线程安全，不是整个对象需要锁，而是一个segment，即一个线程需要一个segment的锁。
• 在 concurrenhashap 中，读操作不需要任何锁。

示例 1：

import java.util.*;
import java.util.concurrent.*;

// 扩展thread类的主类
class gfg extends thread {

 // 创建静态 hashmap 类对象
 static hashmap m = new hashmap();

 public void run()
 {

  // try 块检查异常
  try {

   // 让线程休眠 3 秒
   thread.sleep(2000);
  }
  catch (interruptedexception e) {
  }
  system.out.println("子线程更新映射");
  m.put(103, "c");
 }
 public static void main(string arg[])
  throws interruptedexception
 {
  m.put(101, "a");
  m.put(102, "b");
  gfg t = new gfg();
  t.start();
  set s1 = m.keyset();
  iterator itr = s1.iterator();
  while (itr.hasnext()) {
   integer i1 = (integer)itr.next();
   system.out.println(
    "主线程迭代映射和当前条目是:"
    + i1 + "..." + m.get(i1));
   thread.sleep(3000);
  }
  system.out.println(m);
 }
}

输出：
主线程迭代映射和当前条目是:101...a
子线程更新映射
exception in thread "main" java.util.concurrentmodificationexception
       at java.base/java.util.hashmap$hashiterator.nextnode(hashmap.java:1493)
       at java.base/java.util.hashmap$keyiterator.next(hashmap.java:1516)
       at main.main(main.java:30)

输出说明：

上述程序中使用的类扩展了 thread 类。让我们看看控制流。所以，最初，上面的java程序包含一个线程。当我们遇到语句 main t= new main() 时，我们正在为扩展 thread 类的类创建一个对象。因此，每当我们调用 t.start() 方法时，子线程都会被激活并调用 run() 方法. 现在主线程开始执行，每当子线程更新同一个地图对象时，都会抛出一个名为 concurrentmodificationexception 的异常。    

现在让我们使用 concurrenthashmap 来修改上面的程序，以解决上述程序在执行时产生的异常。

示例 2：

import java.util.*;
import java.util.concurrent.*;

class main extends thread {
 static concurrenthashmap<integer, string> m
  = new concurrenthashmap<integer, string>();
 public void run()
 {
  try {
   thread.sleep(2000);
  }
  catch (interruptedexception e) {
  }
  system.out.println("子线程更新映射");
  m.put(103, "c");
 }
 public static void main(string arg[])
  throws interruptedexception
 {
  m.put(101, "a");
  m.put(102, "b");
  main t = new main();
  t.start();
  set<integer> s1 = m.keyset();
  iterator<integer> itr = s1.iterator();
  while (itr.hasnext()) {
   integer i1 = itr.next();
   system.out.println(
    "主线程迭代映射和当前条目是:"
    + i1 + "..." + m.get(i1));
   thread.sleep(3000);
  }
  system.out.println(m);
 }
}

输出

主线程迭代映射和当前条目是:101...a
子线程更新映射
主线程迭代映射和当前条目是:102...b
主线程迭代映射和当前条目是:103...c
{101=a, 102=b, 103=c}

输出说明：
上述程序中使用的 class 扩展了thread 类。让我们看看控制流，所以我们知道在 concurrenthashmap 中，当一个线程正在迭代时，剩余的线程可以以安全的方式执行任何修改。上述程序中主线程正在更新map，同时子线程也在尝试更新map对象。本程序不会抛出 concurrentmodificationexception。

hashtable、hashmap、concurrenthashmap的区别

hashtable	hashmap	concurrenthashmap
我们将通过锁定整个地图对象来获得线程安全。	它不是线程安全的。	我们将获得线程安全，而无需使用段级锁锁定 total map 对象。
每个读写操作都需要一个objectstotal 映射对象锁。	它不需要锁。	读操作可以不加锁执行，写操作可以用段级锁执行。
一次只允许一个线程在地图上操作（同步）	不允许同时运行多个线程。它会抛出异常	一次允许多个线程以安全的方式操作地图对象
当一个线程迭代 map 对象时，其他线程不允许修改映射，否则我们会得到 concurrentmodificationexception	当一个线程迭代 map 对象时，其他线程不允许修改映射，否则我们会得到 concurrentmodificationexception	当一个线程迭代 map 对象时，其他线程被允许修改地图，我们不会得到 concurrentmodificationexception
键和值都不允许为 null	hashmap 允许一个空键和多个空值	键和值都不允许为 null。
在 1.0 版本中引入	在 1.2 版本中引入	在 1.5 版本中引入

到此这篇关于java中concurrenthashmap是如何实现线程安全的文章就介绍到这了,更多相关java concurrenthashmap线程安全内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！