Paradigma FP y OOP usando técnicas avanzadas de Programación | Programacion Asíncrona

Programación Síncrona vs Programación (A)síncrona

•
• …
•
• …
•
•
•
•

•
•
•
•
•
•
•
•
•

•
•
•
•
•
•
•
•

( Argumentos … ) -> { Bloque de código }
(final String name, final int age) -> { código }
Inferencia de tipos :
(final String name, final int age) -> { código }
(name, age) -> code

•
•
•
•
•
•
• → ⇒ ⇒ ⇒
•

Streams, Function Interface, Multithreading, Producer-Consumer, CompletableFuture…

•
•
•
•
•
•
•
←

/**
* Returns whether all elements of this stream match the provided predicate
* @throws Exception
*/
@Test
public void allMatch() throws Exception {
final boolean result = IntStream.of(0, 1, 2, 3, 4, 5, 6)
.allMatch(it -> it % 1 == 0);
Assert.assertTrue(result);
}

/**Performs a reduction on the elements of this stream, using an associative
* accumulation function, and returns an Optional describing the reduced value, if any.
* @throws Exception
*/
@Test
public void reduce() throws Exception {
final int expected = 789;
final int result = Arrays.asList(18, 19, 29, 23, 43, 266, 789)
.parallelStream()
.reduce((p1, p2) -> p1 > p2 ? p1 : p2)
.get();
Assert.assertTrue(expected == result);
}

•
•
•
•
•
•
• →

/** Expresión lambda que suma un incremento de +1
* @throws Exception
*/
Function<Integer,Integer> add1 = x -> x + 1;
@Test
public void reduce() throws Exception {
final int expected = 2;
final int result = add1.apply(1)
Assert.assertTrue(expected == result);
}

final Runnable runnable = () -> {
String threadName = Thread.currentThread().getName();
System.out.println("Hello " + threadName);
};
final Thread thread = new Thread(runnable,”Thread-1”);
thread.start();
System.out.println("Done!");
_____
new Thread(() -> System.out.println("Hello " + Thread.currentThread().getName())).start();
System.out.println("Done!");
Result : Done!!!
Hello Thread-1

•
•
•
•
•
final ExecuteService executor = Executors.newSingleThreadExecutor();
executor.submit(() -> {
System.out.println("Hello " + Thread.currentThread().getName());
});

final Callable<Integer> callable = () -> {
try {
TimeUnit.SECONDS.sleep(3);
return 1;
}
catch (InterruptedException ex) {
throw new IllegalStateException("callable interrupted", ex);
}
};
final ExecutorService executor = Executors.newFixedThreadPool(1);
final Future<Integer> future = executor.submit(callable);
System.out.println(" Done? " + future.isDone()); // false
Integer result = future.get();
System.out.println(" Done? " + future.isDone()); // true
System.out.print(" Result: " + result); // 1

Emulador Gameboy ( DMG 01 ) | HomeBrew | 2013 - Actual

•
•
•
•
•
•
•
•
•
•

...
LoadAsync Rom
Init
Memory Map
SRAM
OAM
Logo Nintendo
...
Lobby/Cover
Game

public static CompletableFuture<ByteBuffer> read(String filePath, int total) throws Exception {
final CompletableFuture<ByteBuffer> completableFuture = new CompletableFuture();
final AsynchronousFileChannel channel = AsynchronousFileChannel.open(Paths.get(filePath), StandardOpenOption.READ);
final ByteBuffer buffer = ByteBuffer.allocate(total);
channel.read(buffer, 0, null, new CompletionHandler<Integer, Void>() {
@Override public void completed(Integer result, Void attachment) {
try { channel.close(); } catch (IOException e) { e.printStackTrace(); }
buffer.flip();
completableFuture.complete(buffer);
}
@Override public void failed(Throwable exc, Void attachment) {
completableFuture.completeExceptionally(exc);
}
});
});
return completableFuture; }

Coroutines { async, await, yield, fibers, continuation, suspend .. }

fun main(args: Array<String>) {
launch(CommonPool) {
delay(1000L) // Non-blocking
println("World!")
}
println("Hello,")
Thread.sleep(2000L) //Block main thread
}
Result : Hello,
world!
fun main(args: Array<String>) = runBlocking<Unit> {
launch(CommonPool) {
println("World!")
}
println("Hello,")
}
Result : Hello,
world!

fun main(a:Array<String>) = runBlocking<Unit> {
val job = launch(CommonPool) { doWorld() }
println("Hello,")
job.join()
}
suspend fun doWorld() {
delay(1000L)
println("World!")
}
Result : Hello,
world!
fun main(args: Array<String>) = runBlocking<Unit> {
val jobs = List(100000) {
async(CommonPool) {
delay(500L)
print("*")
}
}
jobs.forEach { it.await() }
}
Result : **** ...
Con Thread`s : out-of-memory… (OEME)

GameBoy Emulator Environment - GBEE | HomeBrew | 2017 - Actual

•
•
Covers
- Roms (mirrors…) ***
- Ayuda de la comunidad

Casos prácticos, async, await, promise, generators, yield

Lazy evaluation, Pattern Matching, Type classes, Async, Nomads, Modules …

import Control.Concurrent (threadDelay)
test1 :: Task Int test2 :: Task Int
test1 = task1 $ do threadDelay 500000 test2 = task2$ do threadDelay 500000
putStrLn "Hello," putStrLn " world!"
return 1 return 2
combineTask :: Task Int
combineTask = do
n1 <- test1
n2 <- test2
return (n1 + n2)
main = do
fut <- fork combineTask
n <- fut
print n

import Control.Concurrent.Async
…
main = defaultMain tests
tests = [ testCase "asyncWait" asyncWait ]
value = 42 :: Int
data TestException = TestException deriving (Eq,Show,Typeable)
instance Exception TestException
asyncWait :: Assertion
asyncWait = do
a <- async (return value)
r <- wait a
assertEqual "async_wait" r value

Lazy evaluation, Pattern Matching, Quoted expression , Async, Tail recursive, Interoperabilidad .NET ...

•
•
•
•
•
•
•
•
•
•
•

Paradigma FP y OOP usando técnicas avanzadas de Programación | Programacion Asíncrona

Related slideshows

More Related Content

Paradigma FP y OOP usando técnicas avanzadas de Programación | Programacion Asíncrona