cilk int fib (int n)
{
 if (n<2)
  return n;
 else
 {
  int x, y;
  x = spawn fib (n-1); // fork
  y = spawn fib (n-2); // fork
  sync;  // join
  return (x+y);
 }
}

cilk int main (int argc, char *argv[])
{
 int n, result;
 n = atoi(argv[1]);
 result = spawn fib(n); // fork
 sync; // join
 printf ("Result: %d\n", result);
 return 0;
}

class Fib extends FJTask {
 static final int threshold = 13;
 volatile int number; // arg/result
 Fib(int n) { number = n; }
 int getAnswer() {
  if (!isDone())
  throw new IllegalStateException();
  return number;
 }
 public void run() {
  int n = number;
  if (n <= threshold) // granularity ctl
   number = seqFib(n);
  else {
   Fib f1 = new Fib(n − 1); // fork
   Fib f2 = new Fib(n − 2); // fork
   coInvoke(f1, f2);
   number = f1.number + f2.number; // join
  }
 }

 public static void main(String[] args) {
  try {
   int groupSize = 2; // for example
   FJTaskRunnerGroup group =
    new FJTaskRunnerGroup(groupSize);
   Fib f = new Fib(35); // for example
   group.invoke(f);
   int result = f.getAnswer();
   System.out.println("Answer: " + result);
  }
  catch (InterruptedException ex) {}
 }

 int seqFib(int n) {
  if (n <= 1) return n;
  else return seqFib(n−1) + seqFib(n−2);
 }
}

override int Sum()
{   
   if (depth < 10) return SeqSum();
 
   Task<int> l = new Task<int>( left.Sum );  // fork
   int r         = right.Sum();
   return (r + l.Value);  // join
}

class SimpleSumTask: public tbb::task {
    Value* const sum;
    TreeNode* root;
public:
    SimpleSumTask( TreeNode* root_, Value* sum_ ) : root(root_), sum(sum_) {}
    task* execute() {
        if( root->node_count<1000 ) { // trivial case
            *sum = SerialSumTree(root);
        } else {
            Value x, y;
            int count = 1; 
            tbb::task_list list;
            if( root->left ) {
                ++count;
                list.push_back( *new( allocate_child() ) SimpleSumTask(root->left,&x) );
            }
            if( root->right ) {
                ++count;
                list.push_back( *new( allocate_child() ) SimpleSumTask(root->right,&y) );
            }
            // Argument to set_ref_count is one more than size of the list,
            // because spawn_and_wait_for_all expects an augmented ref_count.
            set_ref_count(count);
            spawn_and_wait_for_all(list); // fork&join
            *sum = root->value;
            if( root->left ) *sum += x;
            if( root->right ) *sum += y;
        }
        return NULL;
    }
};

Value SimpleParallelSumTree( TreeNode* root ) {
    Value sum;
    SimpleSumTask& a = *new(tbb::task::allocate_root()) SimpleSumTask(root,&sum);
    tbb::task::spawn_root_and_wait(a); // fork&join
    return sum;
}

class Join2
{
 public IntCallback firstcb;
 public IntCallback secondcb;
 public Join2()
 {
  firstcb = new IntCallback(first);
  secondcb = new IntCallback(second);
 }
 public void wait(out int i, out int j )
  & async first(int fst)
  & async second(int snd)
 {
  i = fst;
  j = snd;
 }
}

class Client
{
 public static void Main(string[] args)
 {
  Service s1 = . . . ;
  Service s2 = . . . ;
  Join2 x = new Join2();
  s1.Request(args[0], x . firstcb); // fork
  s2.Request(args[1], x . secondcb); // fork
  . . . // do something useful in the meantime. . .
  int i, j ;
  x.wait(out i, out j ); // join
  // wait for both results to come back
  . . . // do something with them
 }
}