private Map<String, String> makeAdreses() {
    
        Map<String, String> adresWhisW = new ConcurrentHashMap();
        Thread thread = new Thread(new IndexedRandomThread(adresWhisW));
        thread.start();
        for (int i = 0; i < 1000; i++) {
                t=//громоздкие вычисления которые нельзя разделить на части;
            adresWhisW( t, i);
        }
 
        try {
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return adresWhisW;
    }
 
 
    public class IndexedRandomThread implements Runnable {
        private Map<String, String> outputMap;
 
        public IndexedRandomThread(Map<String, String> outputMap) {
            this.outputMap = outputMap;
        }
 
        @Override
        public void run() {
            for (int i = 1000; i < 2000; i++) {
                t=//громоздкие вычисления которые нельзя разделить на части
            outputMap.put( t, i);
 
            }
        }
    }

package used;
 
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.*;
 
public class ExecutorServiceExample {
    int countYader = 4;
    public static Map<String, String> adresWhisW = new ConcurrentHashMap();
    CountDownLatch[] cdl = new CountDownLatch[countYader];
 
    public static void main(String args[]) {
        Set<String> ss = new HashSet();
 
        ss.add("вася");
        ss.add("петя");
        ss.add("вася1");
        ss.add("петя1");
        ss.add("вася2");
        ss.add("петя2");
 
        new ExecutorServiceExample(ss);
 
        System.out.println(adresWhisW.size() + "-size");
        for (Map.Entry<String, String> entry : adresWhisW.entrySet()) {
            System.out.println(entry.getKey() + " " + entry.getValue());
        }
 
    }
 
    ExecutorServiceExample(Set<String> ss) {
 
        for (int tr = 0; tr < countYader; tr++) {
            cdl[tr] = new CountDownLatch(6);
        }
 
        ExecutorService executor;
        executor = Executors.newFixedThreadPool(1);
 
        for (int tr = 0; tr < countYader; tr++) {
            executor.execute(new MyThread(cdl[tr], ss, adresWhisW));
        }
        
        try {
            for (int tr = 0; tr < countYader; tr++) {
 
                System.out.println("*");
                cdl[tr].await();
                System.out.println("***");
 
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        executor.shutdown();
 
    }
 
    public class MyThread implements Runnable {
        CountDownLatch latch;
        private Set<String> strSet;
        private Map<String, String> outputMap;
 
        public MyThread(CountDownLatch c, Set<String> strSet, Map<String, String> outputMap) {
            latch = c;
            this.strSet = strSet;
            this.outputMap = outputMap;
            new Thread(this);
        }
 
        @Override
        public void run() {
            for (String str : strSet) {
                str = str + str; //тут будет мнооого вычислений
                outputMap.put(str, str);
                latch.countDown();
            }       
        }
    }
 
}