在线程之间共享数组安全吗？

Question

像我在以下代码中那样在 promise 之间共享一个数组是否安全？

#!/usr/bin/env perl6
use v6;

sub my_sub ( $string, $len ) {
    my ( $s, $l );
    if $string.chars > $len {
        $s = $string.substr( 0, $len );
        $l = $len;
    }
    else {
        $s = $string;
        $l = $s.chars;
    }
    return $s, $l;
}

my @orig = <length substring character subroutine control elements now promise>;
my $len = 7;
my @copy;
my @length;
my $cores = 4;
my $p = @orig.elems div $cores;
my @vb = ( 0..^$cores ).map: { [ $p * $_, $p * ( $_ + 1 ) ] };
@vb[@vb.end][1] = @orig.elems;

my @promise;
for @vb -> $r {
    @promise.push: start {
        for $r[0]..^$r[1] -> $i {
            ( @copy[$i], @length[$i] ) = my_sub( @orig[$i], $len );
        }
    };
}
await @promise;

Answer 1

只需让标有 start 语句前缀 return 值的代码，以便 Perl 6 可以为您处理同步。这就是该功能的重点。
然后你可以等待所有的承诺，并使用 await 语句获得所有结果。

my @promise = do for @vb -> $r {

    start

      do  # to have the ｢for｣ block return its values

        for $r[0]..^$r[1] -> $i {
            $i, my_sub( @orig[$i], $len )
        }
}

my @results = await @promise;

for @results -> ($i,$copy,$len) {
  @copy[$i] = $copy;
  @length[$i] = $len;
}

start 语句前缀仅与并行性无关。
当您使用它时，您是在说，“我现在不需要这些结果，但以后可能会需要”。

这就是它 return 是 Promise (asynchrony), and not a Thread（并发）

的原因

允许运行时实际延迟运行该代码，直到您最终请求结果，即使那样它也可以在同一个线程中按顺序执行所有这些代码。

如果实现确实如此，如果您改为轮询 Promise by continually calling it's .status 方法等待它从 Planned 更改为 Kept 或 Broken，然后才求出结果。
这是默认调度程序将开始处理任何 Promise 代码（如果它有任何备用线程）的部分原因。

推荐看jnthn的演讲“Parallelism, Concurrency, 和 Perl 6 中的异步”.
slides

Answer 2

这个答案适用于我对 MoarVM 情况的理解，不确定 JVM 后端（或 Javascript 后端 fwiw）的最新技术水平。

可以安全地从多个线程读取标量。
可以从多个线程修改标量而不必担心段错误，但您可能会错过更新：

$ perl6 -e 'my $i = 0; await do for ^10 { start { $i++ for ^10000 } }; say $i' 46785

这同样适用于更复杂的数据结构，如数组（例如，推送缺失值）和散列（添加缺失键）。

因此，如果您不介意丢失更新，从多个线程更改共享数据结构应该可行。如果您确实介意丢失更新，我认为这是您通常想要的，您应该按照@Zoffix Znet 和@raiph 的建议，考虑以不同的方式设置您的算法。

Answer 3

这取决于您如何定义 "array" 和 "share"。就数组而言，有两种情况需要分别考虑：

固定大小的数组（已声明my @a[$size]）；这包括具有固定维度的多维数组（例如 my @a[$xs, $ys]）。这些有一个有趣的属性，即支持它们的内存永远不必调整大小。
动态数组（声明为 my @a），按需增长。在引擎盖下，随着它们的增长，它们实际上会随着时间的推移使用大量内存块。

就分享而言，也分三种情况：

由于某些并发控制机制或整体程序结构，多个线程在其生命周期内接触数组，但一次只能接触一个数组的情况。在这种情况下，数组永远不会在 "concurrent operations using the arrays" 意义上共享，因此不可能发生数据竞争。
只读、非懒惰的情况。这是多个并发操作访问非惰性数组的地方，但只是为了读取它。
read/write 情况（包括读取实际导致写入的情况，因为已为数组分配了一些需要延迟评估的内容；请注意，固定大小的数组永远不会发生这种情况，因为它们从不延迟）。

那么我们可以总结出安全性如下：

                     | Fixed size     | Variable size |
---------------------+----------------+---------------+
Read-only, non-lazy  | Safe           | Safe          |
Read/write or lazy   | Safe *         | Not safe      |

* 表示警告，虽然从 Perl 6 的角度来看它是安全的，但您当然必须确保您没有使用相同的索引做冲突的事情。

总而言之，您可以安全地共享固定大小的数组并将其分配给来自不同线程的元素 "no problem"（但要注意虚假共享，这可能会让您为此付出沉重的性能代价）。对于动态数组，只有在共享期间才读取它们才是安全的，即使它们不是惰性的（尽管给定的数组分配主要是急切的，但您不太可能遇到这种情况意外地）。由于不断增长的操作，即使写入不同的元素，也存在数据丢失、崩溃或其他不良行为的风险。

所以，考虑到原来的例子，我们看到my @copy;和my @length;是动态数组，所以我们不能在并发操作中写入它们。但是，出现了这种情况，所以可以确定代码不安全。

这里的其他帖子在指出更好的方向方面做得不错，但是 none 指出了血淋淋的细节。

Answer 4

没有

严重地。其他答案似乎对实现做出了太多假设，none 其中已经过规范测试。

在线程之间共享数组安全吗？

Is it safe, to share an array between threads?

variables

concurrency

raku