PROGRAMMAZIONE AVANZATA JAVA E C

Transcript

1 PROGRAMMAZIONE AVANZATA JAVA E C Massimiliano Redolfi Lezione 9: multithreads, continue Stream in Java 8 Functional Programming stream/package-summary.html import java.util.stream;

2 Stream in Java 8 Functional Programming Da NON confodere con InputStream e simili!!! Stream

3 Stream Stream gli stream sono monads: strutture che definiscono unità computazionali composte da un insieme di step

4 Stream: operation pipepline List<String> mylist = Arrays.asList("a1", "a2", "b1", "c1", "c2"); mylist.stream().filter(s -> s.startswith("c")).map(string::touppercase).sorted().foreach(system.out::println); Le operazioni sugli stream possono essere intermedie o terminali: - intermedie: restituiscono uno stream come risultato - terminali non restituiscono nulla (es. foreach) Stream: operation pipepline Le operazioni sugli stream possono essere intermedie o terminali: - intermedie: restituiscono uno stream come risultato - terminali non restituiscono nulla (es. foreach) mylist.stream().filter(s -> s.startswith("c")).map(string::touppercase).sorted().foreach(system.out::println); Le operazioni sono non-interfering se non alterano lo stream sottostante (modificandone i dati o aggiungendo/togliendo elementi) Le operazioni sono stateless, dipendono solo dai valori specificati dai rispettivi parametri al momento della valutazione delle stesse, non dal contesto

5 Stream: possono essere creati in vari modi Stream.of("alfa", "beta", "gamma").findfirst().ifpresent(system.out::println); IntStream.range(1, 10).filter(v -> v%2 == 0).forEach(System.out::println); Gli stream possono essere generici (Stream) oppure legati a tipi primitivi (IntStream, LongStream, DoubleStream) Arrays.stream(new int[] {1, 2, 3.map(n -> n * n).average().ifpresent(system.out::println); I primitive streams supportano alcuni operatori specifici (average, sum, ) Stream.of("a1", "a2", "a3").map(s -> s.substring(1)).maptoint(integer::parseint).max().ifpresent(system.out::println); Inoltre utilizzano lambda exp. specializzate (IntFunction/ Function, ) IntStream.range(1, 4).mapToObj(i -> "a" + i).foreach(system.out::println); ordine degli operatori

6 Stream: ordine di elaborazione Stream.of("alfa", "beta", "gamma", "delta").filter(s -> { System.out.println("Filtro: " + s); return true; ; se non c è un operazione terminale gli operatori intermedi non vengono elaborati lazines Stream.of("alfa", "beta", "gamma", "delta").filter(s -> { System.out.println("Filtro: " + s); return true;.foreach(s -> System.out.println("For: " + s)); Filtro: alfa For: alfa Filtro: beta For: beta Filtro: gamma For: gamma Filtro: delta For: delta elaborazione verticale degli operatori Stream: ordine di elaborazione Stream.of("alfa", "beta", "gamma", "delta").map(s -> { System.out.println("Map: " + s); return s.touppercase();.anymatch(s -> { System.out.println("Match: " + s); return s.startswith("b"); ; Map: alfa Match: ALFA Map: beta Match: BETA Si elabora solo ciò che serve

7 Stream: ordine di elaborazione Stream.of("alfa", "beta", "gamma", "delta").map(s -> { System.out.println("Map: " + s); return s.touppercase();.filter(s -> { System.out.println("Filter: " + s); return s.startswith("a");.foreach(s -> System.out.println("forEach: " + s)); Map: alfa Filter: ALFA foreach: ALFA Map: beta Filter: BETA Map: gamma Filter: GAMMA Map: delta Filter: DELTA Stream.of("alfa", "beta", "gamma", delta").filter(s -> { System.out.println("Filter: " + s); return s.startswith("a");.map(s -> { System.out.println("Map: " + s); return s.touppercase();.foreach(s -> System.out.println("forEach: " + s)); Filter: alfa Map: alfa foreach: ALFA Filter: beta Filter: gamma Filter: delta l ordine conta! Stream: ordine di elaborazione Stream.of("gamma", "alfa", "beta", "epsilon", "delta").sorted((s1, s2) -> { System.out.printf("Sort: %s; %s\n", s1, s2); return s1.compareto(s2);.filter(s -> { System.out.println("Filter: " + s); return s.startswith("a");.map(s -> { System.out.println("Map: " + s); return s.touppercase();.foreach(s -> System.out.println("ForEach: " + s)); Sort: alfa; gamma Sort: beta; alfa Sort: beta; gamma Sort: beta; alfa Sort: epsilon; beta Sort: epsilon; gamma Sort: delta; epsilon Sort: delta; beta Filter: alfa Map: alfa ForEach: ALFA Filter: beta Filter: delta Filter: epsilon Filter: gamma sorted: operatore intermedio stateful, conserva lo stato durante l esecuzione Nota: viene elaborato in orizzontale per tutti gli elementi della sequenza.

8 Stream: ordine di elaborazione Stream.of("gamma", "alfa", "beta", "epsilon", delta").filter(s -> { System.out.println("Filter: " + s); return s.startswith("a");.sorted((s1, s2) -> { System.out.printf("Sort: %s; %s\n", s1, s2); return s1.compareto(s2);.map(s -> { System.out.println("Map: " + s); return s.touppercase();.foreach(s -> System.out.println("ForEach: " + s)); Filter: gamma Filter: alfa Filter: beta Filter: epsilon Filter: delta Map: alfa ForEach: ALFA l ordine conta! Riutilizzo degli Stream

9 Stream: riutilizzo & Supplier IntStream.iterate(2, f -> 2 * f).anymatch(f -> { System.out.println("Match: " + f); return f > 15; ; Match: 2 Match: 4 Match: 8 Match: 16 IntStream s = IntStream.iterate(2, f -> 2 * f); s.anymatch(f -> { System.out.println("Match: " + f); return f > 15; ; s.anymatch(f -> { System.out.println("Match: " + f); return f > 32; ; Match: 2 Match: 4 Match: 8 Match: 16 Exception in thread "main" java.lang.illegalstateexc eption: stream has already been operated upon or closed at java.util.stream.abstract Pipeline.evaluate(Abstrac tpipeline.java:229) at java.util.stream.intpipel ine.anymatch(intpipeline. java:477) at jexample_threads.main.mai n(main.java:17) Stream: riutilizzo & Supplier Supplier<IntStream> supplier = () -> IntStream.iterate(2, f -> 2 * f); supplier.get().anymatch(f -> { System.out.println("Match: " + f); return f > 15; ; supplier.get().anymatch(f -> { System.out.println("Match: " + f); return f > 32; ; Match: 2 Match: 4 Match: 8 Match: 16 Match: 2 Match: 4 Match: 8 Match: 16 Match: 32 Match: 64 public interface Supplier<T> { T get();

10 Sulla serie di fibonacci Fibonacci jex004_fibonacci # ciclico # ricorsivo # traite iteratori oppure tramite Stream! LongStream fibs = Stream.iterate(new long[]{1, 1, f -> new long[] {f[1], f[0] + f[1].maptolong(f -> f[0]); fibs.limit(10).foreach(system.out::println);

11 Stream & Thread invokeall ExecutorService executor = Executors.newWorkStealingPool(); List<Callable<String>> callables = Arrays.asList( () -> "alfa", () -> "beta", () -> "gamma"); executor.invokeall(callables).stream().map(future -> { try { return future.get(); catch(exception e) { ; return null;.foreach(system.out::println); invokeall: prende una collection di Callable e restituisce una lista di Future alfa beta gamma

12 invokeany ForkJoinPool ExecutorService executor = Executors.newWorkStealingPool(); List<Callable<String>> callables = Arrays.asList( () -> "alfa", () -> "beta", () -> "gamma"); System.out.println(executor.invokeAny(callables)); viene restituito il valore del primo dei Callable che termina invokeany: prende una collection di Callable e blocca l esecuzione sino a che uno dei callable termina, il valore di tale elemento viene quindi restituito Scheduled Thread Pools

13 Task con esecuzione ritardata ScheduledExecutorService executor = Executors.newScheduledThreadPool(1); Runnable task = () -> System.out.println("\nScheduling: " + System.nanoTime()); ScheduledFuture<?> future = executor.schedule(task, 3, TimeUnit.SECONDS); TimeUnit.MILLISECONDS.sleep(1400); long remainingdelay = future.getdelay(timeunit.milliseconds); System.out.printf("Remaining Delay: %sms", remainingdelay); Remaining Delay: 1595ms Scheduling: Task periodici: fixedrate ScheduledExecutorService executor = Executors.newScheduledThreadPool(1); Runnable task = () -> System.out.println("Scheduling: " + new Date()); int initialdelay = 0; int period = 1; executor.scheduleatfixedrate(task, initialdelay, period, TimeUnit.SECONDS); Scheduling: Thu Nov 12 23:42:48 CET 2015 Scheduling: Thu Nov 12 23:42:49 CET 2015 Scheduling: Thu Nov 12 23:42:50 CET 2015 Scheduling: Thu Nov 12 23:42:51 CET 2015 Scheduling: Thu Nov 12 23:42:52 CET 2015 Scheduling: Thu Nov 12 23:42:53 CET 2015 Scheduling: Thu Nov 12 23:42:54 CET 2015 Scheduling: Thu Nov 12 23:42:55 CET 2015 Scheduling: Thu Nov 12 23:42:56 CET 2015 Attenzione: che succede se il task dura 3 secondi?!

14 Task periodici: fixedrate ScheduledExecutorService executor = Executors.newScheduledThreadPool(1); Runnable task = () -> {System.out.println("Scheduling: " + new Date()); try { TimeUnit.SECONDS.sleep(3); catch (Exception e) { ; ; int initialdelay = 0; int period = 1; executor.scheduleatfixedrate(task, initialdelay, period, TimeUnit.SECONDS); Scheduling: Thu Nov 12 23:51:58 CET 2015 Scheduling: Thu Nov 12 23:52:01 CET 2015 Scheduling: Thu Nov 12 23:52:04 CET 2015 Scheduling: Thu Nov 12 23:52:07 CET 2015 Scheduling: Thu Nov 12 23:52:10 CET 2015 Scheduling: Thu Nov 12 23:52:13 CET 2015 Scheduling: Thu Nov 12 23:52:16 CET 2015 Task periodici: fixeddelay ScheduledExecutorService executor = Executors.newScheduledThreadPool(1); Runnable task = () -> {System.out.println("Scheduling: " + new Date()); try { TimeUnit.SECONDS.sleep(3); catch (Exception e) { ; ; int initialdelay = 0; int period = 1; executor.schedulewithfixeddelay(task, initialdelay, period, TimeUnit.SECONDS); Scheduling: Thu Nov 12 23:55:40 CET 2015 Scheduling: Thu Nov 12 23:55:44 CET 2015 Scheduling: Thu Nov 12 23:55:48 CET 2015 Scheduling: Thu Nov 12 23:55:52 CET 2015 Scheduling: Thu Nov 12 23:55:56 CET 2015 Scheduling: Thu Nov 12 23:56:00 CET 2015 Scheduling: Thu Nov 12 23:56:04 CET 2015

15 Concorrenza Concorrenza public class Main { public static void main(string[] args) throws Exception { ExecutorService exec = Executors.newFixedThreadPool(2); Counter counter = new Counter(); IntStream.range(0, 10000).forEach(i -> exec.submit(counter::inc)); exec.shutdown(); exec.awaittermination(60, TimeUnit.SECONDS); System.out.println(counter.count); class Counter { int count = 0; void inc() { count++; ci aspetteremmo 10000, giusto? "

16 Concorrenza public class Main { public static void main(string[] args) throws Exception { ExecutorService exec = Executors.newFixedThreadPool(2); Counter counter = new Counter(); IntStream.range(0, 10000).forEach(i -> exec.submit(counter::inc)); exec.shutdown(); exec.awaittermination(60, TimeUnit.SECONDS); System.out.println(counter.count); class Counter { int count = 0; synchronized void inc() { count++; ok! bisogna sincronizzare!