/// <summary> Fork all tasks in array, and await their completion. /// Behaviorally equivalent to: /// <pre> /// for (int i = 0; i < tasks.length; ++i) tasks[i].fork(); /// for (int i = 0; i < tasks.length; ++i) tasks[i].join(); /// </pre> /// /// </summary> public void CoInvoke(FJTask[] tasks) { FJTaskRunner.coInvoke(tasks); }
/// <summary> Fork both tasks and then wait for their completion. It behaves as: /// <pre> /// task1.fork(); task2.fork(); task2.join(); task1.join(); /// </pre> /// As a simple classic example, here is /// a class that computes the Fibonacci function: /// <pre> /// public class Fib extends FJTask { /// /// // Computes fibonacci(n) = fibonacci(n-1) + fibonacci(n-2); for n> 1 /// // fibonacci(0) = 0; /// // fibonacci(1) = 1. /// /// // Value to compute fibonacci function for. /// // It is replaced with the answer when computed. /// private volatile int number; /// /// public Fib(int n) { number = n; } /// /// public int getAnswer() { /// if (!isDone()) throw new Error("Not yet computed"); /// return number; /// } /// /// public void run() { /// int n = number; /// if (n > 1) { /// Fib f1 = new Fib(n - 1); /// Fib f2 = new Fib(n - 2); /// /// coInvoke(f1, f2); // run these in parallel /// /// // we know f1 and f2 are computed, so just directly access numbers /// number = f1.number + f2.number; /// } /// } /// /// public static void main(String[] args) { // sample driver /// try { /// int groupSize = 2; // 2 worker threads /// int num = 35; // compute fib(35) /// FJTaskRunnerGroup group = new FJTaskRunnerGroup(groupSize); /// Fib f = new Fib(num); /// group.invoke(f); /// int result = f.getAnswer(); /// System.out.println(" Answer: " + result); /// } /// catch (InterruptedException ex) { /// System.out.println("Interrupted"); /// } /// } /// } /// </pre> /// /// </summary> public void CoInvoke(FJTask task1, FJTask task2) { FJTaskRunner.coInvoke(task1, task2); }