Question

我有一个对不可变数组的易变引用，该不可变数组通过用新版本替换引用来异步更改。在此数组上使用foreach进行迭代时，是否保证是线程安全的？

示例：

class MyClass
{ 
  volatile String[] m_array = new String[0];

  public synchronized void add(String n)
  { m_array = ArrayUtils.add(m_array, n); // atomic replace
  }

  public void iterate() // not synchronized!
  { // Do something with each element
    for (String s : m_array)
      System.out.println(s);
  }
}

我为什么要问这个问题？

通常，Java中的foreach循环扩展为Iterator：

Iterator<String> i = m_array.iterator();
while(i.hasNext())
  ...

在这种情况下，只有次访问有效地获取了原子快照。所以一切都很好。

但是如果将来的Java实现对原始数组的优化会怎么办，因为在这种情况下迭代器非常慢？（请参阅foreach vs. for performance）

该实现可能会生成类似

的代码

for (int i = 0; i < m_array.length; i++)
{ String s = m_array[i];
  ...

由于不再访问m_array，因此这不再是线程安全的。在这种情况下，当字段易变时，需要一个快照为m_array的临时变量。

是否保证上述优化永远不会以这种方式发生，并且我的代码示例是否保证安全？

Answer 1

是的，对于volatile字段的异步更改，在volatile数组引用上使用增强的for循环是线程安全的。

理性

但是如果将来的Java实现为原始数组优化foreach会怎么办，因为在这种情况下迭代器非常慢？

const functions = require('firebase-functions') const express = require('express') const { Nuxt } = require('nuxt') const app = express() const config = { dev: false, buildDir: 'nuxt', build: { publicPath: '/public/' } } const nuxt = new Nuxt(config) app.get('**', function (req, res) { res.set('Cache-Control', 'public, max-age=600, s-maxage=1200') console.log('it still works here') nuxt.renderRoute('/').then(result => { console.log(result.html) res.send(result.html) }).catch(e => { console.log(e) res.send(e) }) console.log('After render') }) module.exports.nuxtApp = functions.https.onRequest(app)不用于增强的数组循环，仅用于Iterator。 Java语言规范保证即使每次迭代期间Iterable的值已更改，循环中的每个数组访问也都在每次迭代的同一实例上。使用以下等效代码指定数组的增强型for循环：

m_array

请参见14.14.2。这里的关键点是T[] #a = Expression; L1: L2: ... Lm: for (int #i = 0; #i < #a.length; #i++) { VariableModifiersopt TargetType Identifier = #a[#i]; Statement }（在您的情况下为Expression），仅被评估一次。

需要强调的是，迭代使用的是对数组的引用，而不是数组的副本，因此数组中的元素在迭代过程中可能会发生变化。但是我从您的代码示例中假设您知道这不会发生。

不变的易失性数组上的Java foreach循环线程安全吗？

1 个答案:

理性