public class SumTask extends RecursiveTask<Long>{  
    private static final int THRESHOLD = 10;  
      
    private long start;  
    private long end;  
      
    public SumTask(long n) {  
        this(1,n);  
    }  
      
    private SumTask(long start, long end) {  
        this.start = start;  
        this.end = end;  
    }  
    @Override  
    protected Long compute() {  
        long sum = 0;  
        if((end - start) <= THRESHOLD){  
            for(long l = start; l <= end; l++){  
                sum += l;  
            }  
        }else{  
            long mid = (start + end) >>> 1;  
            SumTask left = new SumTask(start, mid);  
            SumTask right = new SumTask(mid + 1, end);  
            left.fork();  
            right.fork();  
            sum = left.join() + right.join();  
        }  
        return sum;  
    }  
    private static final long serialVersionUID = 1L;  
}

/**
    * Arranges to asynchronously execute this task.  While it is not
    * necessarily enforced, it is a usage error to fork a task more
    * than once unless it has completed and been reinitialized.
    * Subsequent modifications to the state of this task or any data
    * it operates on are not necessarily consistently observable by
    * any thread other than the one executing it unless preceded by a
    * call to {@link #join} or related methods, or a call to {@link
    * #isDone} returning {@code true}.
    *
    * <p>This method may be invoked only from within {@code
    * ForkJoinPool} computations (as may be determined using method
    * {@link #inForkJoinPool}).  Attempts to invoke in other contexts
    * result in exceptions or errors, possibly including {@code
    * ClassCastException}.
    *
    * @return {@code this}, to simplify usage
    */
   public final ForkJoinTask<V> fork() {
       ((ForkJoinWorkerThread) Thread.currentThread())
           .pushTask(this);
       return this;
   }

/**
  * Pushes a task. Call only from this thread.
  *
  * @param t the task. Caller must ensure non-null.
  */
 final void pushTask(ForkJoinTask<?> t) {
     ForkJoinTask<?>[] q; int s, m;
     if ((q = queue) != null) {    // ignore if queue removed
         // 1
         long u = (((s = queueTop) & (m = q.length - 1)) << ASHIFT) + ABASE;
         // 2
         UNSAFE.putOrderedObject(q, u, t);
         // 3
         queueTop = s + 1;         // or use putOrderedInt
         if ((s -= queueBase) <= 2)
             pool.signalWork();
         else if (s == m)
             // 4
             growQueue();
     }
 }

/**
 * Returns the result of the computation when it {@link #isDone is
 * done}.  This method differs from {@link #get()} in that
 * abnormal completion results in {@code RuntimeException} or
 * {@code Error}, not {@code ExecutionException}, and that
 * interrupts of the calling thread do <em>not</em> cause the
 * method to abruptly return by throwing {@code
 * InterruptedException}.
 *
 * @return the computed result
 */
public final V join() {
    // 1
    if (doJoin() != NORMAL)
        return reportResult();
    else
        return getRawResult();
}

/**
    * Possibly runs some tasks and/or blocks, until joinMe is done.
    *
    * @param joinMe the task to join
    * @return completion status on exit
    */
   final int joinTask(ForkJoinTask<?> joinMe) {
       // 1
       ForkJoinTask<?> prevJoin = currentJoin;
       // 2
       currentJoin = joinMe;
       for (int s, retries = MAX_HELP;;) {
           if ((s = joinMe.status) < 0) {
               // 3
               currentJoin = prevJoin;
               // 4
               return s;
           }
           if (retries > 0) {
               if (queueTop != queueBase) {
                   // 5
                   if (!localHelpJoinTask(joinMe))
                       retries = 0;           // cannot help
               }
               else if (retries == MAX_HELP >>> 1) {
                   --retries;                 // check uncommon case
                   // 6
                   if (tryDeqAndExec(joinMe) >= 0)
                       // 7
                       Thread.yield();        // for politeness
               }
               else
                   retries = helpJoinTask(joinMe) ? MAX_HELP : retries - 1;
           }
           else {
               retries = MAX_HELP;           // restart if not done
               pool.tryAwaitJoin(joinMe);
           }
       }
   }

/**
     * If present, pops and executes the given task, or any other
     * cancelled task
     *
     * @return false if any other non-cancelled task exists in local queue
     */
    private boolean localHelpJoinTask(ForkJoinTask<?> joinMe) {
        int s, i; ForkJoinTask<?>[] q; ForkJoinTask<?> t;
        if ((s = queueTop) != queueBase && (q = queue) != null &&
            (i = (q.length - 1) & --s) >= 0 &&
            (t = q[i]) != null) {
            if (t != joinMe && t.status >= 0)
                // 1
                return false;
            if (UNSAFE.compareAndSwapObject
                (q, (i << ASHIFT) + ABASE, t, null)) {
                // 2
                queueTop = s;           // or putOrderedInt
                t.doExec();
            }
        }
        return true;
    }

/**
  * Performs an uncommon case for joinTask: If task t is at base of
  * some workers queue, steals and executes it.
  *
  * @param t the task
  * @return t's status
  */
 private int tryDeqAndExec(ForkJoinTask<?> t) {
     int m = pool.scanGuard & SMASK;
     ForkJoinWorkerThread[] ws = pool.workers;
     // 1
     if (ws != null && ws.length > m && t.status >= 0) {
         for (int j = 0; j <= m; ++j) {
             ForkJoinTask<?>[] q; int b, i;
             ForkJoinWorkerThread v = ws[j];
             if (v != null &&
                 (b = v.queueBase) != v.queueTop &&
                 (q = v.queue) != null &&
                 (i = (q.length - 1) & b) >= 0 &&
                 q[i] ==  t) {
                 // 2
                 long u = (i << ASHIFT) + ABASE;
                 if (v.queueBase == b &&
                     UNSAFE.compareAndSwapObject(q, u, t, null)) {
                     v.queueBase = b + 1;
                     v.stealHint = poolIndex;
                     ForkJoinTask<?> ps = currentSteal;
                     currentSteal = t;
                     t.doExec();
                     currentSteal = ps;
                 }
                 break;
             }
         }
     }
     return t.status;
 }

/**
  * Tries to locate and execute tasks for a stealer of the given
  * task, or in turn one of its stealers, Traces
  * currentSteal->currentJoin links looking for a thread working on
  * a descendant of the given task and with a non-empty queue to
  * steal back and execute tasks from.  The implementation is very
  * branchy to cope with potential inconsistencies or loops
  * encountering chains that are stale, unknown, or of length
  * greater than MAX_HELP links.  All of these cases are dealt with
  * by just retrying by caller.
  *
  * @param joinMe the task to join
  * @param canSteal true if local queue is empty
  * @return true if ran a task
  */
 private boolean helpJoinTask(ForkJoinTask<?> joinMe) {
     boolean helped = false;
     int m = pool.scanGuard & SMASK;
     ForkJoinWorkerThread[] ws = pool.workers;
     if (ws != null && ws.length > m && joinMe.status >= 0) {
         int levels = MAX_HELP;              // remaining chain length
         ForkJoinTask<?> task = joinMe;      // base of chain
         outer:for (ForkJoinWorkerThread thread = this;;) {
             // Try to find v, the stealer of task, by first using hint
             // 1
             ForkJoinWorkerThread v = ws[thread.stealHint & m];
             if (v == null || v.currentSteal != task) {
                 // 2
                 for (int j = 0; ;) {        // search array
                     if ((v = ws[j]) != null && v.currentSteal == task) {
                         // 3
                         thread.stealHint = j;
                         break;              // save hint for next time
                     }
                     if (++j > m)
                         // 4
                         break outer;        // can't find stealer
                 }
             }
             // Try to help v, using specialized form of deqTask
             // 5
             for (;;) {
                 ForkJoinTask<?>[] q; int b, i;
                 if (joinMe.status < 0)
                     // 6
                     break outer;
                 if ((b = v.queueBase) == v.queueTop ||
                     (q = v.queue) == null ||
                     (i = (q.length-1) & b) < 0)
                     // 7
                     break;                  // empty
                 long u = (i << ASHIFT) + ABASE;
                 ForkJoinTask<?> t = q[i];
                 if (task.status < 0)
                     // 8
                     break outer;            // stale
                 // 9
                 if (t != null && v.queueBase == b &&
                     UNSAFE.compareAndSwapObject(q, u, t, null)) {
                     // 10
                     v.queueBase = b + 1;
                     v.stealHint = poolIndex;
                     ForkJoinTask<?> ps = currentSteal;
                     currentSteal = t;
                     t.doExec();
                     currentSteal = ps;
                     helped = true;
                 }
             }
             // Try to descend to find v's stealer
             // 11
             ForkJoinTask<?> next = v.currentJoin;
             if (--levels > 0 && task.status >= 0 &&
                 next != null && next != task) {
                 task = next;
                 thread = v;
             }
             else
                 // 12
                 break;  // max levels, stale, dead-end, or cyclic
         }
     }
     return helped;
 }

/**
     * Possibly blocks waiting for the given task to complete, or
     * cancels the task if terminating.  Fails to wait if contended.
     *
     * @param joinMe the task
     */
    final void tryAwaitJoin(ForkJoinTask<?> joinMe) {
        int s;
        Thread.interrupted(); // clear interrupts before checking termination
        // 1
        if (joinMe.status >= 0) {
            // 2
            if (tryPreBlock()) {
                // 3
                joinMe.tryAwaitDone(0L);
                // 4
                postBlock();
            }
            else if ((ctl & STOP_BIT) != 0L)
                // 5 
                joinMe.cancelIgnoringExceptions();
        }
    }

/**
  * Decrements blockedCount and increments active count
  */
 private void postBlock() {
     long c;
     // 1
     do {} while (!UNSAFE.compareAndSwapLong(this, ctlOffset,  // no mask
                                             c = ctl, c + AC_UNIT));
     int b;
     // 2
     do {} while (!UNSAFE.compareAndSwapInt(this, blockedCountOffset,
                                            b = blockedCount, b - 1));
 }

/**
    * Attempts to cancel execution of this task. This attempt will
    * fail if the task has already completed or could not be
    * cancelled for some other reason. If successful, and this task
    * has not started when {@code cancel} is called, execution of
    * this task is suppressed. After this method returns
    * successfully, unless there is an intervening call to {@link
    * #reinitialize}, subsequent calls to {@link #isCancelled},
    * {@link #isDone}, and {@code cancel} will return {@code true}
    * and calls to {@link #join} and related methods will result in
    * {@code CancellationException}.
    *
    * <p>This method may be overridden in subclasses, but if so, must
    * still ensure that these properties hold. In particular, the
    * {@code cancel} method itself must not throw exceptions.
    *
    * <p>This method is designed to be invoked by <em>other</em>
    * tasks. To terminate the current task, you can just return or
    * throw an unchecked exception from its computation method, or
    * invoke {@link #completeExceptionally}.
    *
    * @param mayInterruptIfRunning this value has no effect in the
    * default implementation because interrupts are not used to
    * control cancellation.
    *
    * @return {@code true} if this task is now cancelled
    */
   public boolean cancel(boolean mayInterruptIfRunning){
       return setCompletion(CANCELLED) == CANCELLED;
   }

/**
  * Marks completion and wakes up threads waiting to join this task,
  * also clearing signal request bits.
  *
  * @param completion one of NORMAL, CANCELLED, EXCEPTIONAL
  * @return completion status on exit
  */
 private int setCompletion(int completion) {
     for (int s;;) {
         if ((s = status) < 0)
             return s;
         if (UNSAFE.compareAndSwapInt(this, statusOffset, s, completion)) {
             if (s != 0)
                 synchronized (this) { notifyAll(); }
             return completion;
         }
     }
 }

private static final int CANCELLED   = -2;

/**
 * Returns the result that would be returned by {@link #join}, even
 * if this task completed abnormally, or {@code null} if this task
 * is not known to have been completed.  This method is designed
 * to aid debugging, as well as to support extensions. Its use in
 * any other context is discouraged.
 *
 * @return the result, or {@code null} if not completed
 */
public abstract V getRawResult();

public final V getRawResult() {
    return result;
}

protected final void setRawResult(V value) {
    result = value;
}

/**
  * Report the result of invoke or join; called only upon
  * non-normal return of internal versions.
  */
 private V reportResult() {
     int s; Throwable ex;
     // 1
     if ((s = status) == CANCELLED)
         throw new CancellationException();
     // 2
     if (s == EXCEPTIONAL && (ex = getThrowableException()) != null)
         UNSAFE.throwException(ex);
     return getRawResult();
 }