Este documento resume los siguientes temas sobre programación paralela en C#:
1) Paralelización de código imperativo usando Parallel.Invoke, Parallel Loops, y manejo de excepciones y particionamiento.
2) Programación paralela con tareas usando Task, tiempos de espera, cancelación, excepciones y retorno de valores.
3) Colecciones de concurrencia como ConcurrentQueue y estructuras para coordinar datos.
Este documento describe la estructura de datos pila mediante cuatro secciones: 1) Descripción y especificación formal del TDA Pila, 2) Ejemplos de uso, 3) Tres implementaciones del TDA Pila basadas en listas, vectores y apuntadores, y 4) Comparación de las implementaciones. Se define una pila como una lista especial LIFO donde todas las operaciones se realizan en un extremo llamado tope, y se especifican las operaciones básicas como crear, vaciar, consultar tope, apilar y desapilar elementos.
El documento describe el TDA Pila, incluyendo su especificación formal e informal, ejemplos de uso y tres posibles implementaciones. Se define una pila como una lista especial donde todas las operaciones se realizan en un extremo llamado tope. Se especifican las operaciones crea, vacia, tope, push y pop. Luego, se detallan implementaciones basadas en listas, vectores y apuntadores simples. Finalmente, se comparan las implementaciones en términos de eficiencia y requerimientos de la aplicación.
Este documento presenta los conceptos básicos relacionados con los tipos de datos abstractos (TDA) pila y cola. Explica las operaciones, implementaciones y ejemplos de uso de pilas y colas mediante listas, vectores y referencias.
El documento describe las especificaciones para desarrollar un programa que simule el interfaz de entrada de una tarjeta de red. La entrada se implementa mediante dos buffers: un primer buffer de 4 tramas y un segundo buffer de espacio ilimitado con 3 puertos. Cuando el primer buffer se llena, envía las 2 tramas de mayor prioridad al segundo buffer. Se creará una clase para instanciar el sistema de entrada y enviar 6 tramas.
El documento describe el desarrollo de un sistema para gestionar partes de un taller mecánico, incluyendo la creación de un menú para crear, listar, mostrar y eliminar partes asociados a las matrículas de los coches. Se utilizará la clase Lector para leer la entrada por teclado y se creará un diagrama UML.
El documento presenta un ejemplo de sincronización de hilos en Java. Se propone crear una clase Contenedor que actúe como buffer para almacenar un número entero de forma que sólo un hilo pueda escribir o borrar el valor a la vez. Se implementan clases ThreadEscribir y ThreadBorrar para gestionar los hilos y una clase TestSincroThreads con el método main para iniciarlos.
Este documento presenta 4 programas desarrollados con monitores en Java para ilustrar conceptos de programación concurrente y paralela. El primer programa simula retiros y depósitos en un cajero automático usando monitores. El segundo programa es similar pero usa semáforos en lugar de monitores. El tercer programa ilustra el uso de un monitor para incrementar y decrementar un valor de forma sincronizada. El cuarto programa incrementa un contador de 1 a 10 de forma sincronizada usando 2 hilos y un monitor.
Este documento proporciona una introducción a las pruebas unitarias. Explica la definición de pruebas unitarias, los marcos de prueba como JUnit, cómo escribir una primera prueba unitaria, diferentes tipos de pruebas, cómo usar Mockito para pruebas con dependencias, y cómo escribir código que sea fácil de probar mediante técnicas como inyección de dependencias. También discute excusas comunes para no escribir pruebas unitarias y cómo detectar código que no es fácil de probar.
Este documento describe la estructura de datos pila mediante cuatro secciones: 1) Descripción y especificación formal del TDA Pila, 2) Ejemplos de uso, 3) Tres implementaciones del TDA Pila basadas en listas, vectores y apuntadores, y 4) Comparación de las implementaciones. Se define una pila como una lista especial LIFO donde todas las operaciones se realizan en un extremo llamado tope, y se especifican las operaciones básicas como crear, vaciar, consultar tope, apilar y desapilar elementos.
El documento describe el TDA Pila, incluyendo su especificación formal e informal, ejemplos de uso y tres posibles implementaciones. Se define una pila como una lista especial donde todas las operaciones se realizan en un extremo llamado tope. Se especifican las operaciones crea, vacia, tope, push y pop. Luego, se detallan implementaciones basadas en listas, vectores y apuntadores simples. Finalmente, se comparan las implementaciones en términos de eficiencia y requerimientos de la aplicación.
Este documento presenta los conceptos básicos relacionados con los tipos de datos abstractos (TDA) pila y cola. Explica las operaciones, implementaciones y ejemplos de uso de pilas y colas mediante listas, vectores y referencias.
El documento describe las especificaciones para desarrollar un programa que simule el interfaz de entrada de una tarjeta de red. La entrada se implementa mediante dos buffers: un primer buffer de 4 tramas y un segundo buffer de espacio ilimitado con 3 puertos. Cuando el primer buffer se llena, envía las 2 tramas de mayor prioridad al segundo buffer. Se creará una clase para instanciar el sistema de entrada y enviar 6 tramas.
El documento describe el desarrollo de un sistema para gestionar partes de un taller mecánico, incluyendo la creación de un menú para crear, listar, mostrar y eliminar partes asociados a las matrículas de los coches. Se utilizará la clase Lector para leer la entrada por teclado y se creará un diagrama UML.
El documento presenta un ejemplo de sincronización de hilos en Java. Se propone crear una clase Contenedor que actúe como buffer para almacenar un número entero de forma que sólo un hilo pueda escribir o borrar el valor a la vez. Se implementan clases ThreadEscribir y ThreadBorrar para gestionar los hilos y una clase TestSincroThreads con el método main para iniciarlos.
Este documento presenta 4 programas desarrollados con monitores en Java para ilustrar conceptos de programación concurrente y paralela. El primer programa simula retiros y depósitos en un cajero automático usando monitores. El segundo programa es similar pero usa semáforos en lugar de monitores. El tercer programa ilustra el uso de un monitor para incrementar y decrementar un valor de forma sincronizada. El cuarto programa incrementa un contador de 1 a 10 de forma sincronizada usando 2 hilos y un monitor.
Este documento proporciona una introducción a las pruebas unitarias. Explica la definición de pruebas unitarias, los marcos de prueba como JUnit, cómo escribir una primera prueba unitaria, diferentes tipos de pruebas, cómo usar Mockito para pruebas con dependencias, y cómo escribir código que sea fácil de probar mediante técnicas como inyección de dependencias. También discute excusas comunes para no escribir pruebas unitarias y cómo detectar código que no es fácil de probar.
Este documento describe las estructuras de datos de pilas y colas. Explica que las pilas siguen el principio LIFO (último en entrar, primero en salir) y las colas siguen el principio FIFO (primero en entrar, primero en salir). También presenta implementaciones de pilas y colas estáticas en Java y C usando vectores, y menciona que las estructuras dinámicas usan listas enlazadas.
El documento describe una aplicación para gestionar información de alumnos, incluyendo altas, bajas y modificaciones. La interfaz tendrá tres pestañas y los datos se almacenarán en una tabla de una base de datos. Se definen las clases Alumno y Dirección para almacenar los datos, y la clase ConexionDDBB para conectarse a la base de datos.
El documento presenta 4 programas escritos en Java que demuestran el uso de hilos concurrentes y paralelos. El primer programa crea una ventana gráfica simple que muestra la palabra "HOLA". Los programas 2 y 3 imprimen cadenas de texto usando hilos con herencia y la interfaz Runnable. El programa 4 establece prioridades y atributos como "daemon" en hilos creados con herencia e interfaz.
Este documento presenta un ejercicio sobre colas implementadas como listas enlazadas. Proporciona el pseudocódigo para las operaciones básicas de cola como crear, comprobar si está vacía, insertar, obtener el primer elemento y eliminar el primer elemento. Luego analiza la complejidad computacional de cada operación, determinando que la mayoría son O(1) excepto la inserción que es O(n) en el peor caso.
Este documento presenta un resumen de las principales características de asyncio, la implementación de referencia de I/O asíncrono en Python descrita en PEP 3156. asyncio proporciona event loops, coroutines, futuros y tareas para manejar operaciones de I/O de forma asíncrona. También incluye transportes y protocolos para crear servidores y clientes TCP/IP asíncronos. El objetivo es proporcionar una implementación moderna de I/O asíncrono que funcione en todas las plataformas soportadas por Python 3.3 o
Este documento describe dos prácticas de programación en C. La primera involucra un programa interactivo para almacenar animales perdidos y encontrados en archivos y verificar coincidencias. La segunda describe un juego donde un ratón se mueve aleatoriamente en una isla tratando de evitar ahogarse o morir de hambre mientras cruza puentes generados al azar. Ambas prácticas involucran el uso de archivos y matrices bidimensionales.
Este documento presenta una lección sobre el lenguaje de transformación de modelos Atlas Transformation Language (ATL). Se introducen conceptos clave como módulos ATL, tipos de datos primitivos y de colecciones en ATL, así como operaciones y características de estos tipos. También se explican conceptos como reglas ATL, helpers y atributos y cómo se pueden usar para transformar modelos.
Programa Java que gestiona los productos que comercializan varios viverosjubacalo
El documento describe un programa Java para gestionar los productos y trabajadores de varios viveros. Se crearán clases para representar productos (plantas y árboles), trabajadores y viveros, con sus atributos y métodos correspondientes. El programa permitirá registrar información de dos viveros con sus productos y trabajadores, regar automáticamente los productos de un vivero calculando la cantidad de agua necesaria, y mostrar datos específicos de los viveros y sus productos.
Este documento compara los tiempos de ejecución de código en Python, C y PyPy para diferentes tipos de cálculos numéricos y operaciones de procesamiento de texto. Los autores realizaron experimentos multiplicando números, matrices y tokens de texto de Shakespeare para medir el rendimiento en cada lenguaje. Encontraron que C es más rápido que Python, especialmente para cálculos intensivos donde el procesador puede optimizarse. Sin embargo, Python puede ser tan rápido como C si se optimiza el código para minimizar el uso de memoria dinámica. PyPy generalmente
Este documento presenta el código para implementar una pila que evalúa si una cadena ingresada es aceptada o rechazada según un conjunto de reglas de producción almacenadas en un archivo de texto. Primero define funciones para leer las reglas de producción, separar los símbolos izquierdos de los derechos y almacenarlos en archivos. Luego evalúa la cadena ingresada comparándola con los símbolos terminales almacenados y determina si es aceptada o rechazada de acuerdo a las reglas.
El documento presenta el código C para implementar una mini shell con diferentes comandos como procesos en abanico, uso de semaforos, creación y copia de archivos, uso de lseek en vectores, comando tail, pipes y tuberías, obtención de la hora del sistema, y medición del tiempo en modo usuario. El código incluye funciones para analizar la entrada del usuario, parsear argumentos, manejar background processes y pipes/tuberías entre procesos.
Ejemplo de RPC (Servidor de Archivos) enviar archivo en Java utilizando RPCIvan Luis Jimenez
Este documento describe el código de un cliente y servidor para transferir archivos mediante llamadas a procedimientos remotos (RPC). El cliente envía el nombre de un archivo al servidor concurrente o secuencial, el cual verifica si existe y lo transfiere de forma concurrente o secuencial respectivamente. Se muestran capturas del proceso de transferencia y resultados cuando el archivo solicitado existe o no existe en el servidor.
Este documento lista y describe funciones de la biblioteca estándar de C para operaciones de E/S, manejo de cadenas, matemáticas, memoria dinámica y más. Incluye funciones para abrir, cerrar y manipular archivos, leer y escribir datos, convertir entre tipos de datos, reservar memoria, ejecutar comandos externos y ordenar vectores.
Este documento presenta información sobre pilas y colas como estructuras de datos dinámicas. Define las operaciones básicas de las pilas y colas como TDA, y describe tres implementaciones comunes para pilas (basada en lista, vectores y referencias) y cuatro implementaciones para colas (basada en lista, vectores circulares, referencias y cursores). También menciona colas especiales como dicolas y colas de prioridad.
El documento proporciona una introducción a la biblioteca estándar de Python. Explica que incluye más de 300 módulos agrupados en categorías como cadenas, tipos de datos, números, archivos, persistencia, compresión, formatos, criptografía, sistema operativo, comunicación e Internet. También describe algunos módulos específicos como sys, time, re, StringIO, datetime y os, entre otros.
El documento describe las listas enlazadas y sus operaciones básicas. Explica que una lista enlazada consiste en nodos conectados entre sí, cada uno con un dato y un enlace al siguiente nodo. Detalla cómo insertar y eliminar nodos al principio o final de la lista, así como recorrerla.
Este documento presenta 20 consejos y trucos para mejorar el rendimiento y la seguridad de MySQL. Algunos de los consejos incluyen la configuración de cuotas de usuario, el uso de UTF-8, la importación y exportación de CSV, la elección adecuada del motor de almacenamiento y la investigación de los diferentes tipos de datos disponibles. El documento también cubre temas avanzados como subconsultas, procedimientos almacenados, gestores y disparadores.
PARADIGMAS FP Y OOP USANDO TÉCNICAS AVANZADAS DE PROGRAMACIÓN ASÍNCRONAVíctor Bolinches
Este documento presenta conceptos sobre programación funcional y orientada a objetos, incluyendo paradigmas de programación, objetos inmutables, lambdas, traits, mixins, comunicación entre procesos asíncrona y síncrona, y el patrón promesa. También describe técnicas de programación funcional como traits, mixins y lambdas en varios lenguajes de programación como Java, C#, C/C++.
Ponencia ofrecida por Oier Blasco en DroidconMAD2013. Sinopsis: La programación reactiva es un paradigma de programación que se centra en los flujos de datos. La presentación trata de cómo podemos usar la programación reactiva para simplificar la programación de tareas asíncronas en android (principalmente las aplicaciones que consumen datos de servicios remotos). Para ello comenzaremos la presentación con una introducción sobre los motivos y los fundamentos de la programación reactiva y como los implementa RxJava (El port open-source hecho por Netflix de la Rx extensions de microsoft). El la segunda para parte de la presentación veremos algunos ejemplos concreto de cómo podemos aplicar estos principios a problemas cotidianos en android.
El documento resume los principales cambios introducidos en Java 7, incluyendo mejoras en el lenguaje como literales binarios, switch con cadenas y try-with-resources, así como nuevas características como invokedynamic, NIO2 y el framework Fork/Join para aprovechar procesadores multicore. También menciona las mejoras planeadas para Java 8 como Coin y soporte para closures.
Este documento describe las estructuras de datos de pilas y colas. Explica que las pilas siguen el principio LIFO (último en entrar, primero en salir) y las colas siguen el principio FIFO (primero en entrar, primero en salir). También presenta implementaciones de pilas y colas estáticas en Java y C usando vectores, y menciona que las estructuras dinámicas usan listas enlazadas.
El documento describe una aplicación para gestionar información de alumnos, incluyendo altas, bajas y modificaciones. La interfaz tendrá tres pestañas y los datos se almacenarán en una tabla de una base de datos. Se definen las clases Alumno y Dirección para almacenar los datos, y la clase ConexionDDBB para conectarse a la base de datos.
El documento presenta 4 programas escritos en Java que demuestran el uso de hilos concurrentes y paralelos. El primer programa crea una ventana gráfica simple que muestra la palabra "HOLA". Los programas 2 y 3 imprimen cadenas de texto usando hilos con herencia y la interfaz Runnable. El programa 4 establece prioridades y atributos como "daemon" en hilos creados con herencia e interfaz.
Este documento presenta un ejercicio sobre colas implementadas como listas enlazadas. Proporciona el pseudocódigo para las operaciones básicas de cola como crear, comprobar si está vacía, insertar, obtener el primer elemento y eliminar el primer elemento. Luego analiza la complejidad computacional de cada operación, determinando que la mayoría son O(1) excepto la inserción que es O(n) en el peor caso.
Este documento presenta un resumen de las principales características de asyncio, la implementación de referencia de I/O asíncrono en Python descrita en PEP 3156. asyncio proporciona event loops, coroutines, futuros y tareas para manejar operaciones de I/O de forma asíncrona. También incluye transportes y protocolos para crear servidores y clientes TCP/IP asíncronos. El objetivo es proporcionar una implementación moderna de I/O asíncrono que funcione en todas las plataformas soportadas por Python 3.3 o
Este documento describe dos prácticas de programación en C. La primera involucra un programa interactivo para almacenar animales perdidos y encontrados en archivos y verificar coincidencias. La segunda describe un juego donde un ratón se mueve aleatoriamente en una isla tratando de evitar ahogarse o morir de hambre mientras cruza puentes generados al azar. Ambas prácticas involucran el uso de archivos y matrices bidimensionales.
Este documento presenta una lección sobre el lenguaje de transformación de modelos Atlas Transformation Language (ATL). Se introducen conceptos clave como módulos ATL, tipos de datos primitivos y de colecciones en ATL, así como operaciones y características de estos tipos. También se explican conceptos como reglas ATL, helpers y atributos y cómo se pueden usar para transformar modelos.
Programa Java que gestiona los productos que comercializan varios viverosjubacalo
El documento describe un programa Java para gestionar los productos y trabajadores de varios viveros. Se crearán clases para representar productos (plantas y árboles), trabajadores y viveros, con sus atributos y métodos correspondientes. El programa permitirá registrar información de dos viveros con sus productos y trabajadores, regar automáticamente los productos de un vivero calculando la cantidad de agua necesaria, y mostrar datos específicos de los viveros y sus productos.
Este documento compara los tiempos de ejecución de código en Python, C y PyPy para diferentes tipos de cálculos numéricos y operaciones de procesamiento de texto. Los autores realizaron experimentos multiplicando números, matrices y tokens de texto de Shakespeare para medir el rendimiento en cada lenguaje. Encontraron que C es más rápido que Python, especialmente para cálculos intensivos donde el procesador puede optimizarse. Sin embargo, Python puede ser tan rápido como C si se optimiza el código para minimizar el uso de memoria dinámica. PyPy generalmente
Este documento presenta el código para implementar una pila que evalúa si una cadena ingresada es aceptada o rechazada según un conjunto de reglas de producción almacenadas en un archivo de texto. Primero define funciones para leer las reglas de producción, separar los símbolos izquierdos de los derechos y almacenarlos en archivos. Luego evalúa la cadena ingresada comparándola con los símbolos terminales almacenados y determina si es aceptada o rechazada de acuerdo a las reglas.
El documento presenta el código C para implementar una mini shell con diferentes comandos como procesos en abanico, uso de semaforos, creación y copia de archivos, uso de lseek en vectores, comando tail, pipes y tuberías, obtención de la hora del sistema, y medición del tiempo en modo usuario. El código incluye funciones para analizar la entrada del usuario, parsear argumentos, manejar background processes y pipes/tuberías entre procesos.
Ejemplo de RPC (Servidor de Archivos) enviar archivo en Java utilizando RPCIvan Luis Jimenez
Este documento describe el código de un cliente y servidor para transferir archivos mediante llamadas a procedimientos remotos (RPC). El cliente envía el nombre de un archivo al servidor concurrente o secuencial, el cual verifica si existe y lo transfiere de forma concurrente o secuencial respectivamente. Se muestran capturas del proceso de transferencia y resultados cuando el archivo solicitado existe o no existe en el servidor.
Este documento lista y describe funciones de la biblioteca estándar de C para operaciones de E/S, manejo de cadenas, matemáticas, memoria dinámica y más. Incluye funciones para abrir, cerrar y manipular archivos, leer y escribir datos, convertir entre tipos de datos, reservar memoria, ejecutar comandos externos y ordenar vectores.
Este documento presenta información sobre pilas y colas como estructuras de datos dinámicas. Define las operaciones básicas de las pilas y colas como TDA, y describe tres implementaciones comunes para pilas (basada en lista, vectores y referencias) y cuatro implementaciones para colas (basada en lista, vectores circulares, referencias y cursores). También menciona colas especiales como dicolas y colas de prioridad.
El documento proporciona una introducción a la biblioteca estándar de Python. Explica que incluye más de 300 módulos agrupados en categorías como cadenas, tipos de datos, números, archivos, persistencia, compresión, formatos, criptografía, sistema operativo, comunicación e Internet. También describe algunos módulos específicos como sys, time, re, StringIO, datetime y os, entre otros.
El documento describe las listas enlazadas y sus operaciones básicas. Explica que una lista enlazada consiste en nodos conectados entre sí, cada uno con un dato y un enlace al siguiente nodo. Detalla cómo insertar y eliminar nodos al principio o final de la lista, así como recorrerla.
Este documento presenta 20 consejos y trucos para mejorar el rendimiento y la seguridad de MySQL. Algunos de los consejos incluyen la configuración de cuotas de usuario, el uso de UTF-8, la importación y exportación de CSV, la elección adecuada del motor de almacenamiento y la investigación de los diferentes tipos de datos disponibles. El documento también cubre temas avanzados como subconsultas, procedimientos almacenados, gestores y disparadores.
PARADIGMAS FP Y OOP USANDO TÉCNICAS AVANZADAS DE PROGRAMACIÓN ASÍNCRONAVíctor Bolinches
Este documento presenta conceptos sobre programación funcional y orientada a objetos, incluyendo paradigmas de programación, objetos inmutables, lambdas, traits, mixins, comunicación entre procesos asíncrona y síncrona, y el patrón promesa. También describe técnicas de programación funcional como traits, mixins y lambdas en varios lenguajes de programación como Java, C#, C/C++.
Ponencia ofrecida por Oier Blasco en DroidconMAD2013. Sinopsis: La programación reactiva es un paradigma de programación que se centra en los flujos de datos. La presentación trata de cómo podemos usar la programación reactiva para simplificar la programación de tareas asíncronas en android (principalmente las aplicaciones que consumen datos de servicios remotos). Para ello comenzaremos la presentación con una introducción sobre los motivos y los fundamentos de la programación reactiva y como los implementa RxJava (El port open-source hecho por Netflix de la Rx extensions de microsoft). El la segunda para parte de la presentación veremos algunos ejemplos concreto de cómo podemos aplicar estos principios a problemas cotidianos en android.
El documento resume los principales cambios introducidos en Java 7, incluyendo mejoras en el lenguaje como literales binarios, switch con cadenas y try-with-resources, así como nuevas características como invokedynamic, NIO2 y el framework Fork/Join para aprovechar procesadores multicore. También menciona las mejoras planeadas para Java 8 como Coin y soporte para closures.
Expositor: Guillermo Winkler
Resumen:
Sabiendo que nunca vamos a lograr escribir tests que prueben que el código es correcto, en esta charla vamos a ver cómo en lugar de escribir tests para casos específicos de entradas de nuestro sistema, podemos declarar propiedades que tiene que cumplir nuestro sistema, y que sea la propia infraestructura que encuentre los casos para los cuáles dichas propiedades no se cumplen.
Un repaso a la historia e implementación de QuickCheck con casos prácticos en Clojure y Javascript.
Property Based Testing usando QuickCheckguillecabeza
El documento introduce el concepto de property based testing, una técnica de pruebas que define propiedades generales que un sistema debe cumplir y luego genera valores aleatorios para probar dichas propiedades de forma exhaustiva. Explica cómo definir propiedades, generar datos de prueba y validar que las propiedades se cumplen para diferentes lenguajes como JavaScript y Clojure. Finalmente, destaca que esta técnica permite probar un sistema en más estados que los unit tests tradicionales y complementa otros enfoques como los tipos.
Este documento resume los conceptos fundamentales de la administración de procesos y procesadores en sistemas operativos. Explica que un proceso es una instancia de ejecución de un programa que está siendo ejecutado. Los procesos pueden encontrarse en diferentes estados como en ejecución, listo o bloqueado. También introduce los conceptos de procesos ligeros o hilos, concurrencia, exclusión mutua, sincronización y mecanismos de semáforos para la coordinación de procesos concurrentes.
Este documento proporciona una introducción a JavaScript (JS). Explica que JS es un lenguaje de programación interpretado, orientado a objetos y débilmente tipado que se ejecuta en el lado del cliente. Describe características como su sintaxis, tipos de datos, operadores, estructuras de control de flujo, funciones predefinidas y de usuario, y el ámbito de las variables. También cubre temas como la interpretación, imperatividad, orientación a objetos, prototipado, tipado débil y dinamismo de JS.
Este documento presenta una introducción a Scala y Apache Spark. Incluye información sobre la instalación de Scala y Apache Spark, una introducción al lenguaje Scala cubriendo cadenas, números, clases implícitas y más, y finalmente una introducción a Apache Spark con un ejemplo en Scala.
Procesamiento de datos a gran escala con Apache SparkSoftware Guru
Apache Spark es un framework para procesamiento de datos en paralelo que permite el procesamiento de los mismos en la memoria. Es hasta 100x más rápido que Apache Hadoop. Hoy en día las aplicaciones estarán pensadas para DataWorkflows y Spark te permite esta interacción con esos datos ya sea en Scala o Python. Adicionalmente puedes aplicar una seríe de Transformaciones a esos datos y aplicar procesamiento en Grafos (GraphX) Machine Learning (MLLib)
Este documento resume las nuevas características de Java 8, incluyendo interfaces funcionales, expresiones lambda, el Stream API y el nuevo motor de JavaScript Nashorn. Las interfaces funcionales permiten implementar métodos de una sola línea, mientras que las expresiones lambda proporcionan una forma más concisa de escribir código anónimo. El Stream API facilita el procesamiento de datos de forma declarativa mediante cadenas de operaciones, y Nashorn permite ejecutar código JavaScript directamente en la JVM.
Este documento presenta una introducción a la concurrencia en Java, incluyendo temas como threads, Runnable, Callable, synchronized, Atomic, Future, ExecutorService, ThreadPool, ForkJoinPool, ForkJoinTask, ParallelStream y la ley de Amdahl. Proporciona código de ejemplo para ilustrar el uso de threads, comunicación entre threads, Executors y CompletableFuture. El objetivo es llevar al lector de principiante a competente en conceptos básicos de concurrencia en Java.
El documento describe diferentes estructuras de control repetitivas o iterativas en Java, incluyendo bucles while, for y do while. Estos bucles permiten ejecutar código de forma repetida mientras se cumpla una condición. Se proveen ejemplos de cómo calcular tablas de multiplicar, sumatorias y factoriales usando estos bucles.
El documento presenta las estructuras iterativas, en particular el ciclo for. Explica que el ciclo for consta de tres partes: la expresión de inicio, la expresión de condición y la expresión de incremento/decremento. Además, provee ejemplos detallados del uso del ciclo for en Java para iterar sobre un rango de números e imprimirlos.
Introducción a Celery y las colas de tareas asíncronasalbertoalcolea
Introducción al framework Celery y a las colas de tareas asíncronas en Python.
Código fuente de los ejemplos disponible aquí:
https://github.com/albertoalcolea/charla-celery
Este documento presenta una introducción a la computación paralela con .NET 4.0. Cubre conceptos como multithreading vs paralelismo, y las nuevas características de paralelismo en .NET 4.0 como PLINQ, Parallel y Task. Incluye varias demostraciones de cómo usar estas características para mejorar el rendimiento de aplicaciones mediante el aprovechamiento de procesadores multi-núcleo.
Este documento presenta información sobre programación paralela basada en paso de mensajes. Cubre temas como la creación de procesos de forma estática y dinámica, el uso de rutinas genéricas para el paso de mensajes entre procesos de forma bloqueante y no bloqueante, y técnicas de comunicación como broadcast y multicast entre grupos de procesos.
1. El documento introduce el lenguaje de programación Java, el cual es orientado a objetos y multiplataforma. 2. Explica las ventajas de Java como su orientación a objetos, simplicidad, portabilidad entre plataformas, robustez y facilidades para programación en red. 3. Cubre conceptos básicos de Java como tipos de datos, declaraciones, expresiones, conversiones de tipos, instrucciones de control e introducción a clases, arreglos, argumentos de programa y manejo de excepciones.
Este documento proporciona una introducción a JDBC y las bases de datos en Java. Explica los conceptos clave como conexiones a bases de datos, ejecución de sentencias SQL, tipos de statements, prepared statements, stored procedures, transacciones y más. También incluye ejemplos de código para establecer conexiones, consultas, inserciones, actualizaciones y eliminaciones de datos.
1. El documento introduce el lenguaje de programación Java, el cual es orientado a objetos. 2. Explica las ventajas de Java como su orientación a objetos, portabilidad multiplataforma, recolección de basura automática y facilidades para programación en red. 3. Cubre conceptos básicos de Java como tipos de datos, declaraciones, expresiones, instrucciones de control, clases, métodos, excepciones y sockets para comunicación en red.
Similar a Getting deeper with TPL & async (Spanish version) (20)
Fijación, transporte en camilla e inmovilización de columna cervical II.pptxjanetccarita
Explora los fundamentos y las mejores prácticas en fijación, transporte en camilla e inmovilización de la columna cervical en este presentación dinámica. Desde técnicas básicas hasta consideraciones avanzadas, este conjunto de diapositivas ofrece una visión completa de los protocolos cruciales para garantizar la seguridad y estabilidad del paciente en situaciones de emergencia. Útil para profesionales de la salud y equipos de respuesta ante emergencias, esta presentación ofrece una guía visualmente impactante y fácil de entender.
"Abordando la Complejidad de las Quemaduras: Desde los Orígenes y Factores de...AlexanderZrate2
Las quemaduras, una de las lesiones traumáticas más comunes, representan un desafío significativo para el cuerpo humano. Estas lesiones pueden ser causadas por una variedad de agentes, desde el contacto con el calor extremo hasta la exposición a productos químicos corrosivos, la electricidad y la radiación. Independientemente de su origen, las quemaduras pueden provocar un amplio espectro de daños, que van desde lesiones superficiales de la piel hasta afectaciones graves de tejidos más profundos, con potencial para comprometer la vida del individuo afectado.
La incidencia y gravedad de las quemaduras pueden variar según factores como la edad, la ocupación, el entorno y la atención médica disponible. Las quemaduras son un problema global de salud pública, con impacto no solo en la salud física, sino también en la calidad de vida y la salud mental de los afectados. Además del dolor y la discapacidad física que pueden ocasionar, las quemaduras pueden dejar cicatrices permanentes y aumentar el riesgo de infecciones y otras complicaciones a largo plazo.
El manejo adecuado de las quemaduras es esencial para minimizar el riesgo de complicaciones y promover una recuperación óptima. Desde los primeros auxilios en el lugar del incidente hasta el tratamiento médico especializado en centros de quemados, se requiere una atención integral y multidisciplinaria. Además, la prevención juega un papel fundamental en la reducción de la incidencia de quemaduras, mediante la educación pública, la implementación de medidas de seguridad en el hogar, el trabajo y otros entornos, y la promoción de políticas de salud y seguridad efectivas.
En esta exploración exhaustiva sobre el tema de las quemaduras, analizaremos en detalle los diferentes tipos de quemaduras, sus causas y factores de riesgo, los mecanismos fisiopatológicos involucrados, las complicaciones potenciales y las estrategias de tratamiento y prevención más relevantes en la actualidad. Además, consideraremos los avances científicos y tecnológicos recientes que están transformando el enfoque hacia la gestión de las quemaduras, con el objetivo último de mejorar los resultados para los pacientes y reducir la carga global de esta importante condición médica.
¿Qué es?
El VIH es un virus que ataca el sistema inmunitario del cuerpo humano, debilitándolo y dejándolo vulnerable a otras infecciones y enfermedades.
Se transmite a través de fluidos corporales como sangre, semen, secreciones vaginales y leche materna.
A medida que avanza, el VIH puede desarrollarse en SIDA, una etapa avanzada de la infección donde el sistema inmunitario está severamente comprometido.
Estadísticas
Más de 38 millones de personas viven con VIH en todo el mundo, según datos de la ONU.
Las tasas de infección varían según la región y el grupo demográfico, con una prevalencia más alta en África subsahariana.
Modos de Transmisión
El VIH se transmite principalmente a través de relaciones sexuales sin protección, compartir agujas contaminadas y de madre a hijo durante el parto o la lactancia.
No se transmite por contacto casual como estrechar la mano o compartir utensilios.
Prevención y Tratamiento
La prevención incluye el uso de preservativos durante las relaciones sexuales, evitar compartir agujas y acceder a la profilaxis preexposición (PrEP) para aquellos con mayor riesgo.
El tratamiento del VIH implica el uso de terapia antirretroviral (TAR), que ayuda a controlar la replicación viral y permite que las personas con VIH vivan vidas más largas y saludables
2. Temas:
• TPL
• Paralelización de código imperativo.
• Programación Paralela con tareas(Task).
• Colecciones de Concurrencia y Pipelines.
• Estructuras para la coordinación de los datos.
• Async
4. • Paralelización de código imperativo
•Parallel.Invoke, Parallel Loops, Cancelando, Excepciones, Particionando .
• Programación Paralela con tareas(Task)
•Task, TimeOuts, Cancelando, Excepciones, Retornando valores.
• Colecciones de Concurrencia y Pipelines
•ConcurrentQueue, ConcurrentStack, ConcurrentBag, BlockingCollection,
ConcurrentDictionary.
5. Parallel Class
( System.Threading.Tasks )
Parallel.For
Parallel.ForEach
Parallel.Invoke
6. Parallel.Invoke
La manera más simple de paralelizar varios métodos.
Sintaxis:
Invoke( Action [] )
Invoke( ParallelOptions, Action [] )
No se tiene garantía de orden.
No retorna hasta que cada
invocación no hay finalizado.
GoToRiver GoToPark GoToZoo GoToPlainArea
Parallel.Invoke(Walk.GoToPark, Walk.GoToRiver, Walk.GoToZoo, Walk.GoToPlainArea);
Parallel.Invoke(
() => Walk.GoToPark("Santiago"),
Walk.GoToRiver,
delegate() { Walk.GoToZoo("26st"); },
Walk.GoToPlainArea);
Patrón
Fork/Join
7. 3 posibles escenarios de paralelismo Escenario
Ideal
Ejemplo hipotético con una arquitectura con
4 núcleos lógicos.
1era ejecución
GoToZoo
GoToRiver
GoToPark
GoToPlainArea
2da ejecución
GoToPark
GoToRiver
GoToPlainArea
GoToZoo
3era ejecución
GoToZoo
GoToPlainArea
GoToRiver
GoToPark
8. Ventajas y Desventajas
1. Es un método muy simple de lograr paralelismo sin tareas, ni hilos.
1. Métodos con notables diferencias en cuanto al tiempo de ejecución.
2. Cada llamada crea una sobrecarga antes de correr los métodos.
3. Como todo código en paralelo, esta expuesto a existencias de
interdependencia e incontrolables interacciones.
4. No tiene garantía de orden.
9. Análisis de tiempo con respecto al secuencial
Walk.GoToPark();
Walk.GoToRiver();
Walk.GoToZoo();
Walk.GoToPlainArea();
Ejemplo hipotético (figuras)con una
arquitectura con 4 núcleos lógicos y
mediciones con 2 núcleos lógicos
Parallel.Invoke(Walk.GoToPark, Walk.GoToRiver, Walk.GoToZoo, Walk.GoToPlainArea);
10. Parallel.For
Versión paralelizada del clásico for.
Sintaxis:
For( Int32, Int32, Action<Int32> )
For( Int32, Int32, Action<Int32, ParallelLoopState> )
List<string> data = new List<string>(){"Estamos","paralelizando","el","for","y","el","foreach"};
Tradicional Paralelizado
for (int i = 0; i < data.Count; i++)
{
Console.Write(i);
}
Parallel.For(0, data.Count, x =>
{
Console.Write(x);
});
No tiene por que cumplirse el orden.
Tener en cuenta si los elementos
estan relacionados entre si.
Desde LowerBound a UpperBound.
El primer parámetro es inclusivo,
el segundo exclusivo.
Load-
Balance
Pequeños bodies.
11. Análisis de tiempo con respecto al secuencial(RayTracing)
void Render(Scene scene, Color[,] rgb)
{
for (int y = 0; y < screenHeight; y++)
{
for (int x = 0; x < screenWidth; x++)
rgb[x,y] = TraceRay(new Ray(scene,x,y));
}
}
void Render(Scene scene, Color[,] rgb)
{
Parallel.For(0, screenHeight, delegate(int y)
{
for (int x = 0; x < screenWidth; x++)
rgb[x,y] = TraceRay(new Ray(scene,x,y));
});
}
Ocho núcleos y 350 x 350
Secuencial: 1.7 fps
Paralelo : 12 fps
Dos núcleos y 350 x 350
Secuencial: 1.0 fps
Paralelo : 2.0 fps
Dos núcleos y 578 x 485
Secuencial: 0.5 fps
Paralelo : 1.0 fps
12. Análisis de tiempo con respecto al secuencial(Primos)
List<int> primes = new List<int>();
int cotaSup = 50000;
for (int i = 2; i < cotaSup; i++)
{
if (isPrime(i))
primes.Add(i);
}
Parallel.For(2, cotaSup, (i) =>
{
if (isPrime(i))
primes.Add(i);
});
0.5 segundos
0.2 segundos
0.5/0.2 = 2.5x
Ejemplo hipotético (figuras)con una
arquitectura con 4 núcleos lógicos y
mediciones con 2 núcleos lógicos
13. F#
let sentences = [|"Estamos"; "paralelizando"; "el"; "for"; "y"; "el";
"foreach"|]
for index=0 to sentences.Length do
printfn "%d" index
printfn ""
let accion indice =
printfn "%d" indice
Parallel.For(0,sentences.Length, new Action<int>(accion))
Console.ReadKey();
14. Parallel.ForEach
Versión paralelizada del clásico foreach.
Sintaxis:
ForEach <TSource>( IEnumerable <TSource>, Action <TSource> )
ForEach <TSource>( IEnumerable <TSource>, Action <TSource, ParallelLoopState> )
List<string> data = new List<string>(){"Estamos","paralelizando","el","for","y","el","foreach"};
foreach (var items in data)
{
Console.Write(items + " ");
}
Tradicional Paralelizado
Parallel.ForEach(data, x =>
{
Console.Write(x + " ");
});
15. Análisis de tiempo con respecto al secuencial
Ejemplo hipotético (figuras)con una
arquitectura con 4 núcleos lógicos y
mediciones con 2 núcleos lógicos
foreach (var i in inputData)
{
if (isPrime(i))
resultData[indice] = i;
indice++;
}
28 segundos
14 segundos
var op = Partitioner.Create(inputData);
Parallel.ForEach(op, (item, loopState, index) =>
{
28/14 = 2x
if (isPrime(item))
resultData[index] = item;
});
17. Manejo de Excepciones
AggregateException
Formato:
try
{
.....
.....
}
catch (AggregateException aggEx)
{
foreach (Exception ex in aggEx.InnerExceptions)
{
Console.WriteLine(string.Format("Caught exception '{0}'",ex.Message));
}
}
18. Manejo de Excepciones
Ejemplo:
try
{
ParallelLoopResult loopResult = Parallel.For(0, 10, (x, state) =>
{
if (x < 5)
Console.WriteLine(x);
else
{
var ex = "Excepción en el índice " + x;
throw new InvalidDataException(ex);
}
});
Console.WriteLine("Ciclo for completado: {0}", loopResult.IsCompleted);
}
catch (AggregateException aggEx)
{
foreach (var innerException in aggEx.InnerExceptions)
{
//Pueden haber 2 excepciones a causa del paralelismo.
Console.WriteLine("Excepcion capturada: " + innerException.Message);
}
}
19. ParallelOptions
ParallelOptions.MaxDegreeOfParallelism
ParallelOptions.TaskScheduler
ParallelOptions.CancellationToken
Se utilizan en los
métodos de Parallel.
var source = Enumerable.Range(8, 2000).ToArray();
double[] result = new double[source.Length];
ParallelOptions parallelOptions = new ParallelOptions();
parallelOptions.MaxDegreeOfParallelism = Environment.ProcessorCount*2; //Ejemplo
Parallel.ForEach(Partitioner.Create(8, source.Length),parallelOptions, range =>
{
for (int i = range.Item1; i < range.Item2; i++)
result[i] = source[i]*Math.E;
});
20. Particionando
Partición por rangos Partición por bloques
Partitioner.Create(1,40)
Parallel.ForEach(Partitioner.Create(10, 200), range =>
{
Console.WriteLine("{0},{1}",range.Item1,range.Item2);
for (int i = range.Item1; i < range.Item2; i++)
{
data[i] = data[i]*i;
}
});
Optimizando el particionado según el número de núcleos.
Partitioner.Create(1,40, ((numeroDeElementos
/numeroDeNucleos)+1))
System.Environment.ProcessorCount
Sintaxis:
Create <TSource >( IEnumerable<TSource > )
Create ( Int32, Int32)
Create ( Int32, Int32, Int32)
24. Ciclo de vida y estado de una tarea
EnumTaskStatus
Miembros:
Created
WaitingForActivation
WaitingToRun
Running
WaitingForChildrenToComplete
RanToCompletion
Canceled
Faulted
25. Invocando Tareas
GenerateSomething GenerateNothing
Parallel.Invoke(GenerateSomething,() => GenerateNothing());
//Los métodos no están corriendo todavía, pero las tareas
están listas para empezar.
//El estado para ambas tareas es TaskStatus.Created.
var task1 = new Task(GenerateSomething);
var task2 = new Task(() => GenerateNothing());
task1.Start();
task2.Start();
Task.WaitAll(task1, task2);
var task1 = Task.Factory.StartNew(() => GenerateNothing());
26. TimeOuts
var task1 = new Task(GenerateSomethingTimeOut);
var task2 = new Task(() => GenerateNothing());
task1.Start();
task2.Start();
if(!Task.WaitAll(new Task[]{task1,task2},300))
{
Console.WriteLine("GenerateSomething y GenerateNothing han tardado más de
300ms");
}
if(!task1.Wait(300))
{
Console.WriteLine("GenerateSomething ha tardado más de 300ms");
}
27. Manejando excepciones con las Task
static void GenerateSomethingCancel(CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
Console.WriteLine("GenerateSomething");
Thread.Sleep(3000);
if (sw.Elapsed.Seconds > 1)
throw new TimeoutException("La tarea se demoró mas de 1 segundos");
cancellationToken.ThrowIfCancellationRequested();
}
try
{
// Espera por que todas las tareas finalicen en menos de 3 segundos
if (!Task.WaitAll(new Task[] { task1, task2 }, 3000))
{
Console.WriteLine("GenerateSomething y GenerateNothing han tardado más de 300ms en terminar");
Console.WriteLine(task1.Status.ToString());
Console.WriteLine(task2.Status.ToString());
}
}
catch (AggregateException ex)
{
foreach (Exception innerEx in ex.InnerExceptions)
{
Console.WriteLine(innerEx.ToString());
}
}
28. Retornando valores desde las tareas
static List<string> GenerateSomethingReturn()
{
Console.WriteLine("GenerateSomething");
Thread.Sleep(3000);
return new List<string>{"Estoy","retornando","una","lista","de","strings."};
}
var task1 = Task.Factory.StartNew(() => GenerateSomethingReturn());
try
{
task1.Wait();
}
catch (AggregateException ex)
{
foreach (Exception innerEx in ex.InnerExceptions)
{
Console.WriteLine(innerEx.ToString());
}
}
var task2 = Task.Factory.StartNew(() =>
{
foreach (var result in task1.Result)
{
Console.WriteLine(result);
}
});
29. Cancelando Tareas usando Tokens
CancellationToken cancellationToken
CancellationTokenSource
Se pasa como parámetro
Controla la cancelación desde el método principal
static void GenerateSomethingCancel(CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
Console.WriteLine("GenerateSomething");
Thread.Sleep(3000);
cancellationToken.ThrowIfCancellationRequested();
}
var cts = new CancellationTokenSource();
var ct = cts.Token;
var task1 = Task.Factory.StartNew(() => GenerateNothingCancel(ct),ct);
cts.Cancel();
if (task1.IsCanceled)
{
Console.WriteLine("La Tarea GenerateSomethingCancel que estaba en ejecucion fue cancelada");
}
30. TaskCreationOptions
Optimizando el código
TaskCreationOptions.AttachedToParent
TaskCreationOptions.None
TaskCreationOptions.LongRunning
TaskCreationOptions.PreferFairness
var task2 = Task.Factory.StartNew(() =>
Ayudar al Scheduler
{
foreach (var result in task1.Result)
{
Console.WriteLine(result);
}
},TaskCreationOptions.PreferFairness);
31. Concatenando múltiples tareas usando Continuación
try
{
var task1 = Task.Factory.StartNew(() => GenerateSomethingCancelReturn(ct), ct);
var task2 = task1.ContinueWith(t =>
{
foreach (var result in t.Result)
{
Console.WriteLine(result);
}
});
task1.Wait();
}
catch (AggregateException ex)
{
foreach (Exception innerEx in ex.InnerExceptions)
{
Console.WriteLine(innerEx.ToString());
}
}
var task2 = Task.Factory.StartNew(() =>
{
foreach (var result in task1.Result)
{
Console.WriteLine(result);
}
});
32. var f = Task.Factory;
var build1 = f.StartNew(() => Build(project1));
var build2 = f.StartNew(() => Build(project2));
var build3 = f.StartNew(() => Build(project3));
var build4 = build1.ContinueWith(() => Build(project4));
var build5 = f.ContinueWhenAll(new[] { build1, build2, build3 }, () => Build(project5));
var build6 = f.ContinueWhenAll(new[] { build3, build4 }, () => Build(project6));
var build7 = f.ContinueWhenAll(new[] { build5, build6 }, () => Build(project7));
var build8 = build5.ContinueWith(() => Build(project8));
Task.WaitAll(build1, build2, build3, build4, build5, build6, build7, build8);
34. TaskContinuationOptions
TaskContinuationOptions.AttachedToParent
TaskContinuationOptions.ExecuteSynchronously
TaskContinuationOptions.LongRunning
TaskContinuationOptions.PreferFairness
TaskContinuationOptions.None
TaskContinuationOptions.NotOnCanceled
TaskContinuationOptions.NotOnFaulted
TaskContinuationOptions.NotOnRanToCompletion
TaskContinuationOptions.OnlyOnCanceled
TaskContinuationOptions.OnlyOnFaulted
TaskContinuationOptions.OnlyOnRanToCompletion
var task2 = task1.ContinueWith(t =>
{
foreach (var result in t.Result)
{
Console.WriteLine(result);
}
},TaskContinuationOptions.None);
Especificando el comportamiento
de la próxima tarea
Condicionando la próxima tarea
35. Análisis de tiempo con respecto a los Thread
Ejemplo hipotético con una arquitectura
con 2 núcleos lógicos.
64 Threads versus 64 Tasks
1. Los primos hasta el 50 : Thread 0.9 segundos.
Tasks 0.2 segundos.
2. Los primos hasta el 500 : Thread 2 segundos.
Tasks 1 segundo.
3. Los primos hasta el 5000 : Thread 15 segundos.
Tasks 13 segundos.
4. Los primos hasta el 50000: Thread 116 segundos.
Tasks 104 segundos.
36. • Paralelización de código imperativo
•Parallel.Invoke, Parallel Loops, Cancelando, Excepciones, Particionando .
• Programación Paralela con tareas(Task)
•Task, TimeOuts, Cancelando, Excepciones, Retornando valores.
• Colecciones de Concurrencia y Pipelines
•ConcurrentQueue, ConcurrentStack, ConcurrentBag, BlockingCollection,
ConcurrentDictionary.
37. var data = new List<int>();
Parallel.ForEach(Partitioner.Create(0, 200), range =>
{
for (int i = range.Item1; i < range.Item2; i++)
lock (data)
data.Add(i);
});
data.ForEach(x => Console.Write(x + " "));
Solución
41. ConcurrentQueue<T>
-Esta coleccion es completamente libre de lock (lock-free)
-Usa compare and swap (CAS)
-Cuando falla una operacion CAS se pone en estado de
contencion.
42. ConcurrentQueue<T>
-Produce (over-head).
-Mejora el rendimiento de la cola y otras colecciones
thread-unsafe, en determinados escenarios.
-Nos facilita el trabajo con la concurrencia.
43. ConcurrentQueue<T>
Caracteristicas importantes:
concurrentQueue.Enqueue(item);
if (concurrentQueue.TryPeek(out item))
{
DoSomething(item);
}
if (concurrentQueue.TryDequeue(out item))
{
DoSomething(item);
}
46. ConcurrentStack<T>
-Similar a la coleccion ConcurrentQueue.
-Es una coleccion LIFO.
-Atomicidad en los metodos PushRange y PopRange reduce la cantidad
de insersiones y extracciones concurrentes en la coleccion.
47. ConcurrentStack<T>
Caracteristicas importantes:
concurrentStack.Push(item);
if (concurrentStack.TryPeek(out item))
{
DoSomething(item);
}
if (concurrentStack.TryPop(out item))
{
DoSomething(item);
}
49. ConcurrentStack<T>
Sintaxis:
count = s.TryPopRange(numberArray, 0, numberArray.Length);
count = s.TryPopRange(numberArray);
Count sera la cantidad de objetos que fueron sacados del tope de
la cola e insertados el el array.
50. TPL - Colecciones de Concurrencia y Pipelines
Atomiciadad o costo…
PushRange
TryPopRange
Push
TryPop
Buen rendimiento
Igual concurrencia
No Over-Head
No memoria
adicional
Over-Head
Memoria adicional
Atomiciadad
Menor
concurrencia
52. ConcurrentBag<T>
-Ideal para ciertos escenarios productor-consumidor.
-No es completamente lock-free.
-Bastante ineficiente, donde el hilo productor es distinto al consumidor.
-Mantiene una cola local para cada hilo que accede a ella.
54. BlockingCollection<T>
Métodos Importantes:
Add
TryAdd
Take
TryTake
CompleteAdding
GetConsumerEnumerable
Ofrece soporte para Bounding y Blocking.
Ideal para escenarios Productor – Consumidor.
Ideal para implementaciones de pipelines.
Capacidad máxima opcional.
Permite cancelación a través de tokens.
Es un wrapper para una interfaz del tipo IProducerConsumerCollection<T>
Existen 2 tipos de enumeraciones con foreach:
1. Enumeración de solo lectura.
2. Enumeración que elimina los elementos que han sido enumerados(P-C).
55. BlockingCollection<T>
Caracteristicas importantes:
BlockingCollection<int> stackBC = new BlockingCollection<int>
(new ConcurrentStack<int>());
BlockingCollection<int> bagBC = new BlockingCollection<int>
(new ConcurrentBag<int>());
BlockingCollection<int> bc = new BlockingCollection<int>(count);
56. BlockingCollection<T>
Caracteristicas importantes:
IsCompleted, IsAddingCompleted.
string aux;
while (!sentences.IsCompleted)
{
if (sentences.TryTake(out aux))
upperSentences.Add(aux.ToUpper());
}
upperSentences.CompleteAdding();
58. BlockingCollection<T>
Caracteristicas importantes:
if (!_sentencesBC.TryAdd(newSentence, 2000, cancToken))
{
throw new TimeoutException(
"_sentencesBC took more than 2 seconds to add an item");
}
catch (OperationCanceledException ex)
{
// The operation was cancelled
break;
}
60. BlockingCollection<T>
Caracteristicas importantes:
BlockingCollection<TOutput>.AddToAny(array, item, _token);
BlockingCollection<TOutput>.TryAddToAny(array, item,
timeOut, _token);
Estos metodos devuelven el indice de la coleccion, en el array de
colecciones, a la cual se le agrego el elemento.
61. BlockingCollection<T>
Caracteristicas importantes:
BlockingCollection<TOutput>.TakeFromAny(array, out item, _token);
BlockingCollection<TOutput>.TakeFromAny(array, out item,
timeOut, _token);
Estos metodos devuelven el indice de la coleccion, en el array de
colecciones, de la cual se elimino el elemento.
62. BlockingCollection<T>
-Facilita el trabajo con las colecciones thread-safe.
-Produce Over-Head.
-Disminuye la cantidad y simplfica la complejidad del codigo.
-Ideal para la implementacion de pipelines(Ejemplo)
63. ConcurrentDictionary<T>
Lock-Free para
operaciones de
lectura
Métodos Importantes:
AddOrUpdate
GetEnumerator
GetOrAdd
TryAdd
TryGetValue
TryRemove
TryUpdate
Sintaxis:
ConcurrentDictionary<TKey, TValue >()
ConcurrentDictionary<TKey, TValue >(Int32, Int32)
int initialCapacity = 100;
int concurrencyLevel = Environment.ProcessorCount * 2;
ConcurrentDictionary<int, int> cd = new ConcurrentDictionary<int,
int>(concurrencyLevel, initialCapacity);
for (int i = 0; i < 64; i++)
cd[i] = i * i;
Console.WriteLine(“23² is {0} (should be {1})", cd[23], 23 * 23);
66. Asynchronous
Programming
Model(APM)
Event-based
Asynchronous
Pattern(EAP)
Task
Asynchronous
Pattern(TAP)
Patrones estándares
Idea
Sincrónico = Asincrónico
TAP
APM
EAP
67. Microsoft Visual Studio AsyncCommunity Technology Preview (CTP).
( Visual Studio Async CTP )
Nuevas keywords:
async:
await:
Marca a métodos o expresiones lambdas como asincrónicas.
Retiene el control hasta que la operación asincrónica termine.
Objetivo:
Programación asincrónica = Programación sincrónica.
Escribir códigos simples y fáciles de entender.
Fin de los métodos callback.
68. public int SumPageSizes(IList<Uri> uris)
{
int total = 0;
foreach (var uri in uris)
{
statusText.Text = string.Format("Found {0} bytes ...", total);
var data = new WebClient().DownloadData(uri);
total += data.Length;
}
statusText.Text = string.Format("Found {0} bytes total", total);
return total;
}
Versión Sincrónica
Problemas:
Bloquea la interfaz de usuario.
No nos va enseñando el estado de la descarga.
Solución Versión Asincrónica
69. Versión Asíncrona con EAP
public void SumPageSizesAsync(IList<Uri> uris)
{
SumPageSizesAsyncHelper(uris.GetEnumerator(), 0);
}
private void SumPageSizesAsyncHelper(IEnumerator<Uri> enumerator, int total)
{
if (enumerator.MoveNext())
{
statusText.Text = string.Format("Found {0} bytes ...", total);
var client = new WebClient();
client.DownloadDataCompleted += (sender, e) => SumPageSizesAsyncHelper(enumerator,
total + e.Result.Length);
client.DownloadDataAsync(enumerator.Current);
}
else
{
statusText.Text = string.Format("Found {0} bytes total", total);
enumerator.Dispose();
}
}
Problemas:
Hay que romper el foreach.
En cada llamado se ancla un evento.
El código es recursivo.
No retorna el total una ves calculado.
70. Conclusiones
El método anterior es asincrónico con una sola llamada asincrónica y una sola
estructura de control alrededor de esta. Imagínense más llamadas asincrónicas
y más estructuras de control, sería un verdadero caos.
Primera solución: Utilizar APM o EAP con las nuevas clases de TPL.
Segunda solución: Utilizar TAP(junto a async).
public async Task<int> SumPageSizesAsyncBest(IList<Uri> uris)
{
int total = 0;
foreach (var uri in uris)
{
statusText.Text = string.Format("Found {0} bytes ...", total);
var data = await new WebClient().DownloadDataTaskAsync(uri);
total += data.Length;
}
statusText.Text = string.Format("Found {0} bytes total", total);
listBox1.Items.Add(total.ToString());
return total;
}
71. let asyncProcessFile (filePath : string) =
async {
printfn "Procesando fichero [%s]" (Path.GetFileName(filePath))
use fileStream = new FileStream(filePath,FileMode.Open)
let bytesToRead = int fileStream.Length
let! data = fileStream.AsyncRead(bytesToRead) //Returna un objeto Async<byte[]>
printfn “Se leyeron [%d] bytes" data.Length
use resultFile = new FileStream(filePath + ".results", FileMode.Create)
do! resultFile.AsyncWrite(data,0,data.Length)
printfn "Finalizado el procesamiento del archivo [%s]" <| Path.GetFileName(filePath)
} |> Async.Start
asyncProcessFile "./testAsync.txt"
Console.ReadKey();
async en F#
72. Retorno
public async void SumPageSizesAsyncBestOther(IList<Uri> uris){
int total = 0;
foreach (var uri in uris)
{
statusText.Text = string.Format("Found {0} bytes ...", total);
var data = await new WebClient().DownloadDataTaskAsync(uri);
total += data.Length;
}
statusText.Text = string.Format("Found {0} bytes total", total);
listBox1.Items.Add(total.ToString());
}
( Fire and forget )
private async void sumButton_Click(object sender, RoutedEventArgs e) {
sumButton.IsEnabled = false;
await SumPageSizesAsync(GetUrls()));
sumButton.IsEnabled = true;
}
( Incluyendo genéricas)
73. Código final propuesto
public async Task<int> SumPageSizesAsyncBetter(IList<Uri> uris)
{
var tasks = from uri in uris select new WebClient().DownloadDataTaskAsync(uri);
var data = await TaskEx.WhenAll(tasks);
return await TaskEx.Run(() =>data.Sum(s => s.Length));
}
Nota:
Se propone incluir Run() y WhenAll() en la claseTask cuando async arrive a su
versión final; mientras este en CTP se alojarán en una clase de prueba llamada
TaskEx.
74. ¿Como funciona async?
Original Transformado por el compilador
public static async Task DoSum(int from,int to)
{
int result = await Sum(from, to);
string param = result.ToString() + "rn";
File.AppendAllText(@"./result.txt", param);
}
public static Task<int> Sum(int from, int to)
{
Task<int> sum = TaskEx.Run(() =>
{
int result = 0;
for (int i = from; i <= to; i++)
{
TaskEx.Delay(500);
result += i;
}
return result;
});
return sum;
}
public static Task DoSum(int from,int to)
{
var task1 = Task.Factory.StartNew(() => Sum(from,to));
return task1.ContinueWith((antecedentTask) =>
{
string param = antecedentTask.Result.Result.ToString() + rn";
File.AppendAllText(@"./result.txt", param);
});
}
public static Task<int> Sum(int from, int to)
{
Task<int> sum = TaskEx.Run(() =>
{
int result = 0;
for (int i = from; i <= to; i++)
{
TaskEx.Delay(500);
result += i;
}
return result;
});
return sum;
}
75. Como funciona async
static void Main(string[] args)
{
public static async Task DoSum(int from,int to)
{
int result = await Sum(from, to);
string param = result.ToString() + "rn";
File.AppendAllText(@"./result.txt", param);
}
int number;
string input;
Task myTask = new Task(Console.WriteLine);
while (true)
{
Console.WriteLine("Entre un número: ");
input = Console.ReadLine();
if (string.Empty == input)
break;
number = int.Parse(input);
myTask = DoSum(1, number);
}
myTask.Wait();
}
Continua la ejecución.
Retorna una tarea
Callback En cuanto la tarea finalice.
76. public async Task<int> SumPageSizesAsyncBest(IList<Uri> uris)
{
int total = 0;
foreach (var uri in uris)
{
statusText.Text = string.Format("Found {0} bytes ...", total);
var data = await new WebClient().DownloadDataTaskAsync(uri);
total += data.Length;
}
statusText.Text = string.Format("Found {0} bytes total", total);
listBox1.Items.Add(total.ToString());
return total;
}
Retornando valores desde async
77. Cancelación desde async
C# F#
public async void Inicio(Program program)
{
cts = new CancellationTokenSource();
program.Hola(cts.Token);
Thread.Sleep(1000);
if (cts != null) cts.Cancel();
}
public async Task Hola(CancellationToken ct)
{
Console.WriteLine("Before await");
await TaskEx.Delay(5000);
ct.ThrowIfCancellationRequested();
Console.WriteLine("After await");
}
let cancelableTask =
async {
printfn "Waiting 10 seconds..."
for i = 1 to 10 do
printfn "%d..." i
do! Async.Sleep(1000)
printfn "Finished!"
}
// Callback used when the operation is canceled
let cancelHandler (ex : OperationCanceledException)
=
printfn "The task has been canceled."
Async.TryCancelled(cancelableTask,cancelHandler)
|>Async.Start
Thread.Sleep(2000)
Async.CancelDefaultToken()
78. Excepciones desde async
try
{
string txt = await w.DownloadStringTaskAsync(url);
}
catch(WebException x)
{
--- Handle exception.
}
let asyncOperation =
async {
try
// ...
with
| :? IOException as ioe ->
printfn "IOException: %s" ioe.Message
| :? ArgumentException as ae ->
printfn "ArgumentException: %s" ae.Message
}
Las excepciones
se manejan
igual que de
manera
sincrónica.
Notas del editor
Parallel Class, provee soporte para paralelizar facilmente ciclos y regiones.
Parallel Class, provee soporte para paralelizar fácilmente ciclos y regiones.
Parallel Class, provee soporte para paralelizar fácilmente ciclos y regiones.
Parallel Class, provee soporte para paralelizar fácilmente ciclos y regiones.
Parallel Class, provee soporte para paralelizar fácilmente ciclos y regiones.