Wir werden nun ein Beispiel durchgehen, indem wir eine Aufgabe einmal klassisch seriell, dann mittels Threads und zum Schluss mit Streams realisieren. Wie groß sind die Unterschiede in der Codekomplexität, welche Performanceunterschiede gibt es?
3.1 Die Aufgabe
Beginnen wir mit einem einfachen Interface, Worker (Listing 3.1), in dem zwei Methoden definiert werden, die zur synthetischen Lasterzeugung verwendet werden. Ziel hier ist es, zuerst eine Matrix mit Stützstellen aufzubauen (generateDemoValueMatrix), die danach mittels Splines interpoliert wird (generateInterpolatedValues).
public interface Worker {
public static final int ANZAHL_KURVEN = 200;
public static final int ANZAHL_MESSWERTE = 10;
public static final int MAX_GENERATED_INT = 100;
public abstract List<List<Integer>>
generateDemoValueMatrix();
public abstract List<List<Double>>
generateInterpolatedValues(List<List<Integer>>
baseValues);
}Listing 3.1: Interface „Worker“
Für die Beispiele wurden zwei Teile ausgelagert. Der erste Teil ist die Erzeugung einer Wertereihe (DemoValueGenerator) zur Darstellung der Stützstellen (Listing 3.2). Die Implementierung wurde als Interface mit default-Methode gewählt, was einer JDK 8 Notation entspricht. Die Implementierung selbst erfolgte an der Stelle noch ohne Streams.
public interface DemoValueGenerator {
public default List<Integer>
generateDemoValuesForY() {
final Random random = new Random();
final List<Integer> result
= new ArrayList<>();
for (int i = 0; i < Worker.ANZAHL_MESSWERTE;
i++) {
final int nextInt =
random.nextInt(Worker.MAX_GENERATED_INT);
result.add(nextInt);
}
return result;
}
}Listing 3.2: DemoValueGenerator
Der zweite Teil ist die Berechnung der interpolierten Werte (WorkLoadGenerator), was hier zum einen der Lasterzeugung dient, und zum anderen als Beispiel zum Einbinden von ThirdParty-Code verwendet wird (Listing 3.3).
public class WorkLoadGenerator {
public static final int STEP_SIZE = 100;
private UnivariateFunction createInterpolateFunction(
final List<Integer> values) {
final double[] valueArrayX
= new double[values.size()];
for (int i = 0; i < valueArrayX.length; i++) {
valueArrayX[i] = (double) i * STEP_SIZE;
}
final double[] valueArrayY
= new double[values.size()];
int i = 0;
for (final Integer value : values) {
valueArrayY[i] = (double) value.intValue();
i = i + 1;
}
final UnivariateInterpolator interpolator
= new SplineInterpolator();
final UnivariateFunction function =
interpolator.interpolate(valueArrayX,
valueArrayY);
return function;
}
public List<Double> generate(final List<Integer> v) {
final UnivariateFunction interpolateFunction =
createInterpolateFunction(v);
//baue Kurve auf
final int anzahlValuesInterpolated
= (v.size() - 1) * STEP_SIZE;
final List<Double> result = new ArrayList<>();
for (int i=0; i < anzahlValuesInterpolated - 1;i++) {
final double valueForY
= interpolateFunction.value(i);
result.add(valueForY);
}
return result;
}
}Listing 3.3: WorkLoadGenerator
3.2 Sequenzielle Version
Die sequenzielle Version (Listing 3.4) ist sehr einfach gehalten und dürfte einer ersten Implementierung meist sehr ähnlich sein.
public class WorkerSerial implements Worker {
@Override
public List<List<Double>>
generateInterpolatedValues(
List<List<Integer>> baseValues) {
final WorkLoadGenerator generator
= new WorkLoadGenerator();
final List<List<Double>> result
= new ArrayList<>();
for (final List<Integer> valueList : baseValues) {
final List<Double> doubleList =
generator.generate(valueList);
result.add(doubleList);
}
return result;
}
private DemoValueGenerator valueGenerator
= new DemoValueGenerator(){};
public List<List<Integer...
