you guys do seem to loop (map) over an array while removing elements from it at the same time, try:

stopped = @workers.dup.map { |worker| stop_worker(worker) }

still it should not NPE - so the bug is probably valid.

@kares Thanks for your excellent feedback. Of course it was weird to mutate-and-map an Array. Avoiding that avoided the misbehavior of JRuby. Mutate-and-map may be the key insight to build a short reproducible program for this.

@olleolleolle thanks for confirming - yes array ops probably won't behave correctly e.g. on 1.7.21

def do_remove(v)
  @array.delete(v)
end

@array = [1, 2, 3]
puts @array.map { |v| do_remove(v); v + 1 }.inspect

RubyObject.java:533:in `inspect': java.lang.NullPointerException
    from RubyArray.java:1480:in `inspectAry'
    from RubyArray.java:1510:in `inspect'
    from RubyArray$INVOKER$i$0$0$inspect.gen:-1:in `call'
    from CachingCallSite.java:306:in `cacheAndCall'
    from CachingCallSite.java:136:in `call'
    from npe_array.rb:7:in `__file__'
    from npe_array.rb:-1:in `load'
    from Ruby.java:867:in `runScript'
    from Ruby.java:860:in `runScript'
    from Ruby.java:729:in `runNormally'
    from Ruby.java:578:in `runFromMain'
    from Main.java:395:in `doRunFromMain'
    from Main.java:290:in `internalRun'
    from Main.java:217:in `run'
    from Main.java:197:in `main'

... I'm not sure whether the MRI outcome (prints [2, 4]) is worth chasing down (due its "correctness")

@kares Good eye! I didn't notice that!

I think we can fix this by reloading the RubyArrayFields each loop or something similar, and possibly warn when they change. I'll fiddle with it for a bit this morning.

Here's a simple fix. I'm wondering if we need to audit the other Array methods to ensure they're not making assumptions about the size of the array while they iterate.

diff --git a/core/src/main/java/org/jruby/RubyArray.java b/core/src/main/java/org/jruby/RubyArray.java
index f4e52c0..5b25e30 100644
--- a/core/src/main/java/org/jruby/RubyArray.java
+++ b/core/src/main/java/org/jruby/RubyArray.java
@@ -2279,13 +2279,15 @@ public class RubyArray extends RubyObject implements List, RandomAccess {

         IRubyObject[] arr = new IRubyObject[realLength];

-        for (int i = 0; i < realLength; i++) {
+        int i;
+        for (i = 0; i < realLength; i++) {
             // Do not coarsen the "safe" check, since it will misinterpret AIOOBE from the yield
             // See JRUBY-5434
             arr[i] = block.yield(context, safeArrayRef(values, i + begin));
         }

-        return new RubyArray(runtime, arr);
+        // use iteration count as new size in case something was deleted along the way
+        return new RubyArray(runtime, arr, 0, i);
     }

     @JRubyMethod(name = {"collect"})