遍历列表并将可调用对象提交给ExecutorService

Question

I have a List of users that I want to iterate over and create a Callable for each that is passed to an ExecutorService like so:

ExecutorService executor = Executors.newFixedThreadPool(10);

List<Future<String>> futures = new ArrayList<Future<String>>();

for(final User user : users) {

    Future<String> future = executor.submit(new Callable<String>() {
        @Override
        public String call() throws Exception {
            return doSomethingWithUser(user);
        }
    });

    futures.add( future );      
}

executor.shutdown();

for(Future<String> future : futures) {
    String message = future.get();
    System.out.println(message);        
}   

I believe this won't work correctly, because the user inside the call() method is not the same current user in the iteration when the Callable was created. In other words:

for(final User user : users) {

    System.out.println("User: " + user.username); // The current user

    Future<String> future = executor.submit(new Callable<String>() {
        @Override
        public String call() throws Exception {
            System.out.println("User: " + user.username); // Might not be the same user as above
            return doSomethingWithUser(user);
        }
    });

    futures.add( future );      
}

To fix this, I created a MyCallable class that implements Callable and allows for a constructor

public abstract class MyCallable<I, O> implements Callable<O> {

    private I param;

    public MyCallable(I param) {
        this.param = param;
    }

    public I getParam() {

        return param;
    }
}

Then in my iterator, I pass the user argument to the constructor

for(final User user : users) {

    Future<String> future = executor.submit(new MyCallable<User, String>(user) {
        @Override
        public String call() throws Exception {
            return doSomethingWithUser(user);
        }
    });

    futures.add( future );                  
}

This works, but I'm curious if instead of creating a new class called MyCallable I could just use the Callable as an anonymous inner class as I was before. However, I would instead add a member variable to it.

for(final User user : users) {

    Future<String> future = executor.submit(new Callable<String>() {
        private User _user = user;
        @Override
        public String call() throws Exception {
            return doSomethingWithUser(_user);
        }
    });

    futures.add( future );      
}

Would this work fine? I've tested it, and it seems to work, but I can be kind of difficult to know with multithreading. Member variables are initialized before the constructor, so in theory my _user variable, should have the correct user, right?

Answer 1

Your code will work just fine the way it was originally. Variables used in an anonymous class/lambda are captured when the anonymous class is defined - this is why Java requires them to be effectively final - so you don't need to worry, the value of user will still be the same when the callable runs.