Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package eu.toolchain.perftests;
  
  import java.util.List;
 
 
 
 public class FutureVsSync {
     private static final int AVAILABLE_PROCESSORS = Runtime.getRuntime().availableProcessors();
 
     private static final ExecutorService asyncThreads = Executors.newFixedThreadPool();
     private static final ExecutorService syncThreads = Executors.newFixedThreadPool();
 
     private static final AsyncFramework async = TinyAsync.builder().executor().build();
 
     public static void main(String argv[]) throws Exception {
         final long syncTime;
         final double sync;
         final long asyncTime;
         final double async;
 
         {
             Stopwatch sw = Stopwatch.createStarted();
             sync = sync();
             syncTime = sw.elapsed(.);
         }
 
         {
             Stopwatch sw = Stopwatch.createStarted();
             async = async();
             asyncTime = sw.elapsed(.);
         }
 
         ..println(String.format("sync: %f (%d ns)"syncsyncTime));
         ..println(String.format("async: %f (%d ns)"asyncasyncTime));
         System.exit(0);
     }
 
     private static Collector<DoubleDoublesummer = new Collector<DoubleDouble>() {
         @Override
         public Double collect(Collection<Doubleresultsthrows Exception {
             double sum = 0.0d;
 
             for (final Double r : results)
                 sum += r;
 
             return sum;
         }
     };
 
     private static double async() throws Exception {
         final List<AsyncFuture<Double>> outer = new ArrayList<>();
 
         for (int i = 0; i <  - 1; i++) {
             outer.add(someAsyncCall());
         }
 
         return .collect(outer).get();
     }
 
     private static AsyncFuture<DoublesomeAsyncCall() {
         return .lazyCall(new Callable<AsyncFuture<Double>>() {
             @Override
             public AsyncFuture<Doublecall() throws Exception {
                 final List<AsyncFuture<Double>> inner = new ArrayList<>();
 
                 for (int i = 0; i < 100; i++) {
                     inner.add(.call(new Callable<Double>() {
                         @Override
                         public Double call() throws Exception {
                             return doSomeWork();
                         }
                     }));
                 }
 
                 return .collect(inner);
             }
         });
     }
 
     private static double sync() throws Exception {
         final List<Future<Double>> outer = new ArrayList<>();
 
         for (int i = 0; i <  - 1; i++) {
             outer.add(someSyncCall());
         }
 
         double sum = 0.0d;
        for (final Future<Doublef : outer)
            sum += f.get();
        return sum;
    }
    private static Future<DoublesomeSyncCall() {
        return .submit(new Callable<Double>() {
            @Override
            public Double call() throws Exception {
                final List<Future<Double>> inner = new ArrayList<>();
                for (int i = 0; i < 100; i++) {
                    inner.add(.submit(new Callable<Double>() {
                        @Override
                        public Double call() throws Exception {
                            return doSomeWork();
                        }
                    }));
                }
                double sum = 0.0d;
                for (final Future<Doublef : inner)
                    sum += f.get();
                return sum;
            }
        });
    }
    public static double doSomeWork() {
        double sum = 0.0d;
        for (int i = 0; i < 1000000; i++) {
            sum += Math.sqrt(Math.pow(i, 2));
        }
        return sum;
    }
New to GrepCode? Check out our FAQ X