public class Simultaneous implements Runnable {

    public static final int THREADS = 3;

    public static class Semaphore {

        public boolean set = false;
    }
    public static final Semaphore[] semaphores =
            new Semaphore[THREADS];
    public static final Thread[] threads = new Thread[THREADS];
    public static Random rnd = new Random();
    public final int threadNum;

    public Simultaneous(int num) {
        this.threadNum = num;
    }

    public static int getRndNumber() {
        return rnd.nextInt(1000) * 10;
    }

    @Override
    public void run() {
        synchronized (semaphores) {
            semaphores[this.threadNum].set = true;
            semaphores.notify();
        }

        final long startExec = System.currentTimeMillis();
        executeTask();
        final long finishExec = System.currentTimeMillis();
        System.out.println("Thread N" + this.threadNum + ". Start: "
                + startExec + ". End: " + finishExec
                + ". Total: " + (finishExec - startExec) + ".");
    }
    
    @Transactional
    public void executeTask() {
       тут я хочу выполнять sql select
    }   
}

 public String sqlTest() {
        for (int i = 0; i < Simultaneous.THREADS; i++) {
            Simultaneous.semaphores[i] = new Simultaneous.Semaphore();
        }

        System.out.println("Starting " + Simultaneous.THREADS + " threads...");

        synchronized (Simultaneous.class) {
            synchronized (Simultaneous.semaphores) {
                for (int i = 0; i < Simultaneous.THREADS; i++) {
                    final Simultaneous mainThread = new Simultaneous(i);
                    Simultaneous.threads[i] = new Thread(mainThread, "Thread N" + i);
                    Simultaneous.threads[i].setDaemon(true);
                    Simultaneous.threads[i].start();
                }

                System.out.println("Waiting for simultaneous start...");

                boolean isAllStarted = false;
                while (!isAllStarted) {
                    try {
                        Simultaneous.semaphores.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    isAllStarted = true;
                    for (int i = 0; i < Simultaneous.THREADS; i++) {
                        if (!Simultaneous.semaphores[i].set) {
                            isAllStarted = false;
                            break;
                        }
                    }
                }
            }
        }

        System.out.println("Waiting for threads to finish execution...");

        for (int i = 0; i < Simultaneous.THREADS; i++) {
            try {
                Simultaneous.threads[i].join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        System.out.println("Program terminated successfully.");

        return "";
    }

    @Autowired
    private SessionFactory sessionFactory; 

 class Service implements Runnable {

        private final String name;
        private final int timeToStart;
        private final CountDownLatch latch;

        public Service(String name, int timeToStart, CountDownLatch latch) {
            this.name = name;
            this.timeToStart = timeToStart;
            this.latch = latch;
        }

        @Override
        public void run() {
            try {                
                Thread.sleep(timeToStart);
            } catch (InterruptedException ex) {
                Logger.getLogger(Service.class.getName()).log(Level.SEVERE, null, ex);
            }
            System.out.println(name + " is Up");
            latch.countDown(); //reduce count of CountDownLatch by 1
        }
    }

        int THREADS = 10;
        Thread[] threads = new Thread[THREADS];
        final CountDownLatch latch = new CountDownLatch(THREADS);
        for (int i=0; i<THREADS; i++) {
          threads[i] = new Thread(new Service("Thread"+i, 1000, latch));
          threads[i].start();
        }
        
        try{
            latch.await();  //main thread is waiting on CountDownLatch to finish
            System.out.println("All services are up, Application is starting now");
        }catch(InterruptedException ie){
           ie.printStackTrace();
        }