Result result = service.take().get();

import org.apache.log4j.Logger;
import java.io.File;
import java.util.concurrent.*;

public class Main {
    private static Logger logger = Logger.getLogger(Main.class);

    public static void main(String[] args) {
        logger.debug("main start");

        new Thread(new DirectoryScaner(new File("D:\\test\\txt\\in"))).start();
        new Thread(new DirectoryScaner(new File("D:\\test\\csv\\in"))).start();

        logger.debug("main end");
    }
}

import org.apache.log4j.Logger;

import java.io.File;
import java.io.FileFilter;
import java.util.concurrent.*;

public class DirectoryScaner implements Runnable {

    private static Logger logger = Logger.getLogger(DirectoryScaner.class);

    private File directory;

    public DirectoryScaner(File directory) {
        this.directory = directory;
        logger.debug("new DirectoryScaner " + directory);
    }

    public void run() {
        logger.debug("Start DirectoryScaner run for directory " + directory.getAbsolutePath());

        long random = (long)(Math.random() * 10 + 1)*1000;
        logger.debug("random " + random);
        try {
            Thread.sleep(random);
        } catch (InterruptedException e) {
            logger.error("Получили ошибку InterruptedException",e);
        }

        scan();

        logger.debug("End DirectoryScaner run for directory " + directory.getAbsolutePath());
    }

    private void scan(){
        logger.debug("Start DirectoryScaner scan for directory " + directory.getAbsolutePath());

        ExecutorService executor = Executors.newFixedThreadPool(1);
        CompletionService<Result> service = new ExecutorCompletionService<Result>(executor);

        File[] files = directory.listFiles(new FileFilter() {
            public boolean accept(File pathname) {
                return pathname.isFile();
            }
        });

        logger.debug("Найдено файлов " + files.length);
        for (File file : files) {
            executor.submit(new FileScaner(directory, file));
        }

        executor.shutdown();

        for (int i = 0; i < files.length; i++) {
            try {
                logger.debug("Повисли и ждем результата...");
                Result result = service.take().get();
                logger.debug("Получили результат " + result);

                File dest = new File(directory.getAbsoluteFile() + "\\out\\" + result.getFile().getName());
                result.getFile().renameTo(dest);
                logger.debug("file " + result.getFile() + " renameTo " + dest.getAbsolutePath());

            } catch (InterruptedException e) {
                logger.error("Получили ошибку InterruptedException",e);
            } catch (ExecutionException e) {
                logger.error("Получили ошибку ExecutionException",e);
            }
        }
        logger.debug("Start DirectoryScaner scan for directory " + directory.getAbsolutePath());
    }
}

import org.apache.log4j.Logger;

import java.io.File;
import java.util.concurrent.Callable;

public class FileScaner implements Callable<Result> {

    private static Logger logger = Logger.getLogger(FileScaner.class);
    private File directory;
    private File file;

    public FileScaner(File directory, File file) {
        this.directory = directory;
        this.file = file;
        logger.debug("new FileScaner " + file);
    }

    @Override
    public Result call() throws Exception {

        logger.debug("Start FileScaner call for file " + file.getAbsolutePath());

        long random = (long)(Math.random() * 10 + 1)*1000;
        logger.debug("random " + random + " for file " + file.getAbsolutePath());

        try {
            Thread.sleep(random);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        Result result = new Result();
        result.setFile(file);
        if (directory.equals(new File("D:\\test\\csv\\in"))){
            result.setException(new Exception("!!! call csv Exception"));
        }
        logger.debug("End FileScaner call for file" + file.getAbsolutePath() + " result " + result);

        return result;
    }
}

import java.io.File;

public class Result {
    private File file;
    private Exception exception;

    public File getFile() {
        return file;
    }

    public void setFile(File file) {
        this.file = file;
    }

    public Exception getException() {
        return exception;
    }

    public void setException(Exception exception) {
        this.exception = exception;
    }

    @Override
    public String toString() {
        return "Result{" +
                "file=" + file +
                ", exception=" + exception +
                '}';
    }
}

import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Random;
import java.util.concurrent.*;

public class Test {

    public static class stringCallable implements Callable<String>{
        String mstring;

        stringCallable(String s) {mstring = s;}

        @Override
        public String call() throws Exception {

            Random r = new Random();
            int sec = r.nextInt(5);
            sec = sec * 1000;
            Thread.sleep(sec);
            return mstring+" - "+sec;
        }
    }

    public static void main(String[] args) throws IOException, InterruptedException, ExecutionException {
        ArrayList<Callable<String>> list = new ArrayList<Callable<String>>();
        ExecutorService e = Executors.newFixedThreadPool(5);
        list.add(new stringCallable("1"));
        list.add(new stringCallable("2"));
        list.add(new stringCallable("3"));
        list.add(new stringCallable("4"));
        list.add(new stringCallable("5"));
        System.out.println ("Starting Solver");
        try {
            solve(e, list);
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        } catch (ExecutionException e1) {
            e1.printStackTrace();
        }
        System.out.println ("End Block");
    }

    public static void solve(ExecutorService e, Collection<Callable<String>> solvers) throws InterruptedException, ExecutionException {

        CompletionService<String> ecs = new ExecutorCompletionService<String>(e);
        for (Callable<String> s : solvers){
            ecs.submit(s);
        }

        e.shutdown();

        int n = solvers.size();
        for (int i = 0; i < n; ++i) {
            String r = ecs.take().get();
            if (r != null)
                use(r);
        }
    }
    private static void use(String r) {
        System.out.println (r);
    }
}

        File[] files = directory.listFiles(new FileFilter() {
            public boolean accept(File pathname) {
                return pathname.isFile();
            }
        });

        logger.debug("Найдено файлов " + files.length);
        for (File file : files) {
            service.submit(new FileScaner(directory, file));
        }