Anonymous Inner Class in Groovy not capturing final outer variable state - multithreading

Question

I'm running a test where I take 1,000 Strings that represent an ID. I create an ExecutorService with 100 threads, loop over the 1,000 Strings, and create a Callable for each. This works fine in Java, but I found in Groovy that the anonymous inner class Callable is not storing the iterated value.
Here is my test:
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
class CallableTest {
public static void main( String[] args ) throws InterruptedException, ExecutionException {
CallableTest test = new CallableTest();
test.runTest();
}
public List<String> setupTest(){
List<String> ids = new ArrayList<String>();
for(int i = 0; i < 1000; i++) {
ids.add( "ID_" + i );
}
return ids;
}
public void runTest() throws InterruptedException, ExecutionException {
ExecutorService executor = Executors.newFixedThreadPool(100);
List<Future<String>> futures = new ArrayList<Future<String>>();
List<String> ids = setupTest();
for(final String id : ids) {
Future<String> future = executor.submit(new Callable<String>() {
#Override
public String call() throws Exception {
return doSomethingWithId(id);
}
});
futures.add( future );
}
for(Future<String> future : futures) {
String message = future.get();
System.out.println(message);
}
}
public String doSomethingWithId(String id) {
return "Doing something with ID: " + id;
}
}
The problem in Groovy is here:
for(final String id : ids) {
Future<String> future = executor.submit(new Callable<String>() {
#Override
public String call() throws Exception {
// The ID value here is not the ID value from when the Callable was created
return doSomethingWithId(id);
}
});
futures.add( future );
}
As you can see in my comment, the id value when calling the method doSomethingWithId is not the same value as it was when the Callable was created. This leads to Doing something with ID: ID_999 being printed majority of the time.
If I copy this over to a Java project and run it, it runs as expected. I get Doing something with ID: ID_x from 0-999 with no duplicates.
Why doesn't this work in Groovy? My understanding is that Groovy should support anonymous inner classes, but it appears that the anonymous inner class Callable is not capturing the outer variable id state when it creates the anonymous class. I'm using Java 7 with Groovy 2.3.10.
UPDATE
I found that adding the following made this work:
for(final String id : ids) {
final String myId = id // This makes it work
Future<String> future = executor.submit(new Callable<String>() {
#Override
public String call() throws Exception {
return doSomethingWithId(myId);
}
});
futures.add( future );
}
Seems like Groovy isn't actually making the value returned from the iterator final?