Приложения
Пример расчёта чисел Фибоначчи пример программы на C#.
///
/// Represents Fibonacci number calculation routines.
///
public class Fibonacci
{
private int stepsNumber;
private int result;
private ManualResetEvent calculationComplete;
///
/// Gets this Fibonacci calculation argument.
///
public int StepsNumber { get { return stepsNumber; } }
///
/// Gets this Fibonacci calculation result.
///
public int Result { get { return result; } }
///
/// Creates new Fibonacci number calculation.
///
///
Fibonacci calculation
/// argument.
///
Event,
/// signaling calculation complete.
public Fibonacci(int stepsNumber,
ManualResetEvent calculationComplete)
{
this.stepsNumber = stepsNumber;
this.calculationComplete = calculationComplete;
}
///
/// Starts asynchronous calculation in thread pool.
///
///
Paramenter
/// passing from thread pool.
public void ThreadPoolCallback(object threadContext)
{
int threadIndex = (int)threadContext;
Debug.Print("Thread {0} started...", threadIndex);
result = Calculate(stepsNumber);
Debug.Print("Thread {0} result calculated...",
threadIndex);
calculationComplete.Set();
}
///
/// Synchronously calculates Fibonacci number
/// for specified argument.
///
///
Fibonacci
/// number argument.
/// Fibonacci number result.
public static int Calculate(int stepsNumber)
{
if (stepsNumber <= 1)
{
return stepsNumber;
}
return Calculate(stepsNumber - 1) +
Calculate(stepsNumber - 2);
}
}
///
/// Contains program entry point routines.
///
public class Program
{
private const int numberOfCalculations = 64;
private static ManualResetEvent[] doneEvents =
new ManualResetEvent[numberOfCalculations];
private static int[] arguments =
CreateArguments();
private static int[] results =
new int[numberOfCalculations];
private static Fibonacci[] calculations =
new Fibonacci[numberOfCalculations];
///
/// Program entry point.
///
public static void Main()
{
TimeSpan elapsedTime;
Console.WriteLine("Launching {0} synchronous tasks...",
numberOfCalculations);
elapsedTime = CalculateSynchronous();
Console.WriteLine("All synchronous calculations are complete.");
PrintSynchronousResults(elapsedTime);
Console.WriteLine("Launching {0} asynchronous tasks...",
numberOfCalculations);
elapsedTime = CalculateAsynchronous();
Console.WriteLine("All asynchronous calculations are complete.");
PrintAsynchronousResults(elapsedTime);
}
private static int[] CreateArguments()
{
Random random = new Random();
int[] arguments = new int[numberOfCalculations];
for (int i = 0; i < numberOfCalculations; i++)
{
arguments[i] = random.Next(20, 40);
}
return arguments;
}
private static TimeSpan CalculateSynchronous()
{
DateTime dateStart = DateTime.Now;
for (int i = 0; i < numberOfCalculations; i++)
{
results[i] = Fibonacci.Calculate(arguments[i]);
}
DateTime dateFinish = DateTime.Now;
return dateFinish - dateStart;
}
private static TimeSpan CalculateAsynchronous()
{
DateTime dateStart = DateTime.Now;
for (int i = 0; i < numberOfCalculations; i++)
{
doneEvents[i] = new ManualResetEvent(false);
Fibonacci f = new Fibonacci(arguments[i], doneEvents[i]);
calculations[i] = f;
ThreadPool.QueueUserWorkItem(f.ThreadPoolCallback, i);
}
WaitHandle.WaitAll(doneEvents);
DateTime dateFinish = DateTime.Now;
return dateFinish - dateStart;
}
private static void PrintAsynchronousResults(
TimeSpan elapsedTime)
{
foreach (Fibonacci f in calculations)
{
PrintResult(f.StepsNumber, f.Result);
}
PrintElapsedTime(elapsedTime);
}
private static void PrintSynchronousResults(
TimeSpan elapsedTime)
{
for (int i = 0; i < numberOfCalculations; i++)
{
PrintResult(arguments[i], results[i]);
}
PrintElapsedTime(elapsedTime);
}
private static void PrintResult(
int argument, int result)
{
Console.WriteLine("Fibonacci({0}) = {1}",
argument, result);
}
private static void PrintElapsedTime(
TimeSpan elapsedTime)
{
Console.WriteLine("Elapsed time: {0}",
elapsedTime);
}
}
Пример перемножения матриц на Java.
package ru.supercorporation;
import java.util.Arrays;
import java.util.List;
import java.util.Vector;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
/**
* Math matrix class.
*/
public class Matrix {
protected final int[][] data;
/**
* Get matrix table. [row][column]
*
* @return matrix table
*/
public int[][] getData() {
return data;
}
/**
* @param rawData matrix table
*/
public Matrix(int[][] rawData) {
data = rawData;
}
/**
* Matrix factory.
*
* @param rows rows
* @param columns cols
* @param lessThen fills with random numbers 0<=x<lessThen
* @return matrix
*/
public static Matrix createRandomMatrix(int rows, int columns, int lessThen) {
int[][] raw = new int[rows][columns];
for (int i = 0; i < rows; i++) {
for (int j = 0; j < columns; j++) {
raw[i][j] = (int) (Math.random() * lessThen);
}
}
return new Matrix(raw);
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
} else if (obj instanceof Matrix) {
int[][] data2 = ((Matrix) obj).getData();
for (int i = 0; i < data.length; i++) {
for (int j = 0; j < data2[i].length; j++) {
if (data[i][j] != data2[i][j]) {
return false;
}
}
}
return true;
} else {
return false;
}
}
/**
* @return rows
*/
public int getHeight() {
return data.length;
}
/**
* @return columns
*/
public int getWidth() {
return data[0].length;
}
@Override
public String toString() {
return Arrays.deepToString(data);
}
/**
* @param a first matrix raw data
* @param b second matrix raw data
* @param result resulting matrix
* @param row row number to multiply
*/
private void multiplySingleRow(
int[][] a, int[][] b, int[][] result,
int row) {
int cols = getWidth();
int rows = getHeight();
for (int j = 0; j < cols; ++j) {
result[row][j] += a[row][j] *
b[j][row];
}
}
/**
* Multiply by another matrix in single thread.
*
* @param matrix second matrix
* @return result of multiplication
*/
public Matrix multiply(Matrix matrix) {
int cols = getWidth();
int rows = getHeight();
int[][] result = new int[rows][cols];
for (int i = 0; i < rows; ++i) {
multiplySingleRow(data, matrix.data,
result, i);
}
return new Matrix(result);
}
/**
* Multiply by another matrix with help of {@link java.util.concurrent.ExecutorService}.
*
* @param matrix second matrix
* @param threadsNumber number of simultaneous threads
* @return result of multiplication
*/
public Matrix multiplyExecutorService(final Matrix matrix, int threadsNumber)
throws InterruptedException, ExecutionException {
final int[][] result = new int[getHeight()][getWidth()];
ExecutorService es = Executors.newFixedThreadPool(threadsNumber);
Vector> tasks = new Vector>(data.length);
// task per row
for (int i = 0; i < getHeight(); ++i) {
final int row = i;
tasks.add(new Callable |
