java 使用lock [duplicate] Package 的对象上的ConcurrentModificationException

ntjbwcob  于 2024-01-05  发布在  Java
关注(0)|答案(2)|浏览(179)

此问题在此处已有答案：

Iterating through a Collection, avoiding ConcurrentModificationException when removing objects in a loop（31个回答）
6天前关闭
我把我的应用程序留了一个晚上，第二天早上注意到这样一个堆栈跟踪：

  1. java.util.ConcurrentModificationException: null
  2. at java.base/java.util.LinkedHashMap$LinkedHashIterator.nextNode(LinkedHashMap.java:756) ~[na:na]
  3.     at java.base/java.util.LinkedHashMap$LinkedEntryIterator.next(LinkedHashMap.java:788) ~[na:na]
  4.     at java.base/java.util.LinkedHashMap$LinkedEntryIterator.next(LinkedHashMap.java:786) ~[na:na]
  5.     at ****.MyClass.cleanup(MyClass.kt:150) ~[main/:na]
  6.     at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method) ~[na:na]
  7.     at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:77) ~[na:na]
  8.     at java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) ~[na:na]
  9.     at java.base/java.lang.reflect.Method.invoke(Method.java:568) ~[na:na]
  10.     at org.springframework.scheduling.support.ScheduledMethodRunnable.run(ScheduledMethodRunnable.java:84) ~[spring-context-6.0.12.jar:6.0.12]
  11.     at org.springframework.scheduling.support.DelegatingErrorHandlingRunnable.run(DelegatingErrorHandlingRunnable.java:54) ~[spring-context-6.0.12.jar:6.0.12]
  12.     at org.springframework.scheduling.concurrent.ReschedulingRunnable.run(ReschedulingRunnable.java:96) ~[spring-context-6.0.12.jar:6.0.12]
  13.     at java.base/java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:539) ~[na:na]
  14.     at java.base/java.util.concurrent.FutureTask.run$$$capture(FutureTask.java:264) ~[na:na]
  15.     at java.base/java.util.concurrent.FutureTask.run(FutureTask.java) ~[na:na]
  16.     at java.base/java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.run(ScheduledThreadPoolExecutor.java:304) ~[na:na]
  17.     at java.base/java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1136) ~[na:na]
  18.     at java.base/java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:635) ~[na:na]
  19.     at java.base/java.lang.Thread.run(Thread.java:833) ~[na:na]

字符串
我试图找到一个根本原因，但我不能。所以让我提供我的代码的简化版本：

  1. @Configuration
  2. @EnableConfigurationProperties(MyConnectionProperties::class)
  3. class MyClass(
  4.     private val myProperties: MyConnectionProperties,
  5. ) {
  7.     private val logger: KLogger = KotlinLogging.logger {}
  8.     private val myLock = ReentrantLock()
  9.     private val myHolder: MutableMap<String, MyConnectionExtension> = mutableMapOf()
  10.      
  11.     @Scheduled(cron = "...")
  12.     fun cleanup() {
  13.         val connectionsToClose: MutableList<LDAPConnection> = mutableListOf()
  15.         myLock.withLock {
  16.             myHolder.forEach { (userDn, connectionExtension) ->
  17.                 val lastTouchTime = max(
  18.                     connectionExtension.connection.lastCommunicationTime,
  19.                     connectionExtension.lastPullingTime,
  20.                 )
  21.                 val connectionName = connectionExtension.connection.connectionName
  23.                 
  25.                 if (lastTouchTime + ldapConnectionProperties.lifetimeMs < Instant.now().toEpochMilli()) {
  26.                     myHolder.remove(userDn)
  27.                     connectionsToClose.add(connectionExtension.connection)
  29.                    
  30.                 }
  31.             }
  32.         }
  34.         connectionsToClose.forEach { connection ->
  35.             try {
  36.                 connection.close()               
  37.             } catch (e: Exception) {
  38.                 logger.warn(e) {"....."}
  39.             }
  40.         }
  42.         logger.trace { "job finished" }
  43.     }
  44.     
  45.     private fun getConnection(userId: String, password: String): LDAPConnection {
  46.         myHolder.withLock {
  47.             val connectionExtension = connectionHolder[userId]
  48.             val connection = connectionExtension?.connection
  50.             return if (connection == null || !connection.isConnected) {
  51.                 createConnection(userId, password).also {
  52.                     connectionHolder[userId] = LdapConnectionExtension(
  53.                         connection = it,
  54.                         lastPullingTime = Instant.now().toEpochMilli(),
  55.                     )
  56.                 }
  57.             } else {                
  58.                 connectionExtension.lastPullingTime = Instant.now().toEpochMilli()
  59.                 connection
  60.             }
  61.         }
  62.     }
  63.     ...
  64. }

型
只有2个函数使用myHolder，所以我只提供了它们。从我的Angular 来看，对myHolder的访问是由锁覆盖的，所以即使map在这里不是并发的，也不会有并发问题。
这是怎么了？

Java

2条答案

按热度按时间
zpjtge22

zpjtge221#

正如注解所说，你是remove从一个map中调用，同时用forEach迭代它。forEach旋转一个迭代器，如果你在迭代它的同时改变了map，就会抛出一个ConcurrentModificationException。
解决方案是在一个单独的集合中记录您想要移除的所有元素，然后在forEach迭代之后检查这些元素并将它们从Map中移除。

赞(0）分享  回复(0）举报  2024-01-05
z9smfwbn

z9smfwbn2#

ConcurrentModificationException异常通常在您尝试遍历集合（如List或Map）时发生，并且集合的结构发生更改。尝试在迭代期间修改集合（而不是通过迭代器自己的remove方法）可能会导致此异常。
在你的代码中，当在cleanup（）方法中迭代myHolder并试图修改它时会出现问题。当你调用myHolder.remove（userDn）时，你会改变myHolder的结构，但这是在迭代它时完成的，所以会抛出ConcurrentModificationException。
为了解决这个问题，我们可以在迭代过程中收集要删除的键，然后在迭代完成后删除它们。下面是修复的代码：

  1. @Scheduled(cron = "...")
  2. fun cleanup() {
  3.     val connectionsToClose: MutableList<LDAPConnection> = mutableListOf()
  4.     val keysToRemove: MutableList<String> = mutableListOf()
  6.     myLock.withLock {
  7.         myHolder.forEach { (userDn, connectionExtension) ->
  8.             val lastTouchTime = maxOf(
  9.                 connectionExtension.connection.lastCommunicationTime,
  10.                 connectionExtension.lastPullingTime,
  11.             )
  12.             val connectionName = connectionExtension.connection.connectionName
  14.             logger.trace {
  15.                 "[cleanConnectionHolder]: connection $connectionName: " +
  16.                 "lastTouchTime = ${Instant.ofEpochMilli(lastTouchTime).atZone(ZoneId.systemDefault())}"
  17.             }
  19.             if (lastTouchTime + myProperties.lifetimeMs < Instant.now().toEpochMilli()) {
  20.                 keysToRemove.add(userDn)
  21.                 connectionsToClose.add(connectionExtension.connection)
  23.                 logger.trace { "[cleanConnectionHolder]: Connection $connectionName will be removed from holder" }
  24.             }
  25.         }
  26.     }
  28.     keysToRemove.forEach { keyToRemove ->
  29.         myHolder.remove(keyToRemove)
  30.     }
  32.     connectionsToClose.forEach { connection ->
  33.         try {
  34.             connection.close()
  35.         } catch (e: Exception) {
  36.             logger.warn(e) { "Error closing connection" }
  37.         }
  38.     }
  40.     logger.trace { "Cleanup job finished" }
  41. }

字符串
这个修复代码的核心思想是：
在myLock保护的块中迭代myHolder，并收集所有即将关闭的连接和要删除的键。迭代完成后，退出myLock-protected块并删除键，以便在迭代期间不修改集合结构。此属性是正确的，并且它在MyConnectionProperties类中可用。

展开查看全部
赞(0）分享  回复(0）举报  2024-01-05
我来回答

相关问题

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新问答

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com