El documento describe las diferencias entre procesos y hilos en la programación concurrente. Un proceso tiene sus propios recursos privados como memoria, mientras que los hilos comparten los recursos de un proceso. En Java, la programación concurrente se basa principalmente en hilos. La clase Thread permite crear nuevos hilos que ejecutan el método run() de forma concurrente al hilo principal. También es posible implementar la interfaz Runnable para crear hilos sin heredar de Thread.
The document discusses multi-threading in Java. It defines multi-threading as allowing multiple threads within a process to execute concurrently. It explains that threads share resources of the process but have their own call stacks and program counters. The document outlines the life cycle of a thread in Java and describes how to create threads by implementing the Runnable interface or extending the Thread class. It provides examples of creating and running threads concurrently in Java.
This document discusses Java threads and related concepts like thread states, priorities, synchronization, and inter-thread communication. It covers the two main ways to create threads in Java - by extending the Thread class or implementing the Runnable interface. Synchronization techniques like using synchronized methods and blocks are presented to prevent race conditions when multiple threads access shared resources. Finally, inter-thread communication methods like wait() and notify() from the Object class are introduced.
Java Threads Tutorial | Multithreading In Java Tutorial | Java Tutorial For B...Edureka!
(**** Java Certification Training: https://www.edureka.co/java-j2ee-soa-training ****)
This Edureka tutorial on “Java Threads” will talk about one of the core concepts of Java i.e Java Threads. It will give you a complete insight into how to create, work and synchronize with multiple threads. Through this tutorial you will learn the following topics:
What is a Java Thread?
Thread Lifecycle
Creating a Thread
Main Thread
Multi-Threading
Thread Pool
Check out our Java Tutorial blog series: https://goo.gl/osrGrS
Check out our complete Youtube playlist here: https://goo.gl/gMFLx3
Follow us to never miss an update in the future.
Instagram: https://www.instagram.com/edureka_learning/
Facebook: https://www.facebook.com/edurekaIN/
Twitter: https://twitter.com/edurekain
LinkedIn: https://www.linkedin.com/company/edureka
Multithreading in java is a process of executing multiple threads simultaneously. The thread is basically a lightweight sub-process, the smallest unit of processing. Multiprocessing and multithreading, both are used to achieve multitasking.
Java concurrency allows applications to make use of multiple processors and handle asynchronous operations through the use of threads. While concurrency provides benefits like improved performance, it also introduces risks like race conditions and deadlocks if threads access shared resources unsafely. The Java threading APIs provide tools for safely managing concurrent operations through mechanisms like synchronization, locks, and concurrent collections.
Access our sample Java8 certification questions.
1z0-808 certification questions ready to be used.
For each 1z0-808 certification question you can find the solution, the explanation and the exam objective of 1z0-808
OCA Java SE 8 Exam Chapter 6 Exceptionsİbrahim Kürce
A program can fail for just about any reason. Here are just a few possibilities:
The code tries to connect to a website, but the Internet connection is down.
You made a coding mistake and tried to access an invalid index in an array.
One method calls another with a value that the method doesn't support.
Un directorio es un contenedor virtual en el que se almacenan una agrupación de archivos informáticos y otros subdirectorios, atendiendo a su contenido, a su propósito o a cualquier criterio que decida el usuario. Técnicamente, el directorio almacena información acerca de los archivos que contiene: como los atributos de los archivos o dónde se encuentran físicamente en el dispositivo de almacenamiento.
The document discusses multi-threading in Java. It defines multi-threading as allowing multiple threads within a process to execute concurrently. It explains that threads share resources of the process but have their own call stacks and program counters. The document outlines the life cycle of a thread in Java and describes how to create threads by implementing the Runnable interface or extending the Thread class. It provides examples of creating and running threads concurrently in Java.
This document discusses Java threads and related concepts like thread states, priorities, synchronization, and inter-thread communication. It covers the two main ways to create threads in Java - by extending the Thread class or implementing the Runnable interface. Synchronization techniques like using synchronized methods and blocks are presented to prevent race conditions when multiple threads access shared resources. Finally, inter-thread communication methods like wait() and notify() from the Object class are introduced.
Java Threads Tutorial | Multithreading In Java Tutorial | Java Tutorial For B...Edureka!
(**** Java Certification Training: https://www.edureka.co/java-j2ee-soa-training ****)
This Edureka tutorial on “Java Threads” will talk about one of the core concepts of Java i.e Java Threads. It will give you a complete insight into how to create, work and synchronize with multiple threads. Through this tutorial you will learn the following topics:
What is a Java Thread?
Thread Lifecycle
Creating a Thread
Main Thread
Multi-Threading
Thread Pool
Check out our Java Tutorial blog series: https://goo.gl/osrGrS
Check out our complete Youtube playlist here: https://goo.gl/gMFLx3
Follow us to never miss an update in the future.
Instagram: https://www.instagram.com/edureka_learning/
Facebook: https://www.facebook.com/edurekaIN/
Twitter: https://twitter.com/edurekain
LinkedIn: https://www.linkedin.com/company/edureka
Multithreading in java is a process of executing multiple threads simultaneously. The thread is basically a lightweight sub-process, the smallest unit of processing. Multiprocessing and multithreading, both are used to achieve multitasking.
Java concurrency allows applications to make use of multiple processors and handle asynchronous operations through the use of threads. While concurrency provides benefits like improved performance, it also introduces risks like race conditions and deadlocks if threads access shared resources unsafely. The Java threading APIs provide tools for safely managing concurrent operations through mechanisms like synchronization, locks, and concurrent collections.
Access our sample Java8 certification questions.
1z0-808 certification questions ready to be used.
For each 1z0-808 certification question you can find the solution, the explanation and the exam objective of 1z0-808
OCA Java SE 8 Exam Chapter 6 Exceptionsİbrahim Kürce
A program can fail for just about any reason. Here are just a few possibilities:
The code tries to connect to a website, but the Internet connection is down.
You made a coding mistake and tried to access an invalid index in an array.
One method calls another with a value that the method doesn't support.
Un directorio es un contenedor virtual en el que se almacenan una agrupación de archivos informáticos y otros subdirectorios, atendiendo a su contenido, a su propósito o a cualquier criterio que decida el usuario. Técnicamente, el directorio almacena información acerca de los archivos que contiene: como los atributos de los archivos o dónde se encuentran físicamente en el dispositivo de almacenamiento.
This document discusses multithreading in Java. It defines threads as pieces of code that run concurrently with other threads. It describes the life cycle of a thread as starting, running, and stopping. It also discusses how to create multithreaded programs in Java by either extending the Thread class or implementing the Runnable interface.
An interface in Java is like a class but cannot be instantiated. It defines method signatures and constant values but not method implementations. A class implements an interface by providing method bodies for the abstract methods defined in the interface. Interfaces can extend other interfaces to inherit their methods.
This presentation is about advanced multithreading and concurrency in Java. I have tried my best to explain the concepts with code. Feel free to reach me if you have any questions or concerns.
This document discusses exception handling in C++ and Java. It defines what exceptions are and explains that exception handling separates error handling code from normal code to make programs more readable and robust. It covers try/catch blocks, throwing and catching exceptions, and exception hierarchies. Finally, it provides an example of implementing exception handling in a C++ program to handle divide-by-zero errors.
The document discusses Java Sets and Maps. It describes that a Set is an unordered collection with no duplicates, while a Map maps keys to values with no duplicate keys. Common Set implementations are HashSet, TreeSet, and LinkedHashSet. Common Map implementations are HashMap and TreeMap. The document provides examples of typical operations on Sets like contains, add, remove, and iterating with iterators or enhanced for loops. It also discusses operations on Maps like put, get, remove, and iterating over the keySet, values, or entrySet.
OCA Java SE 8 Exam Chapter 1 Java Building Blocksİbrahim Kürce
The document discusses key concepts in Java including classes, objects, fields, methods, variables, primitive types, reference types, and memory management. It explains that classes are the basic building blocks in Java programs and contain fields and methods. Objects are instances of classes that exist in memory. The document also covers variable scope, default initialization, and garbage collection in Java.
Multithreading allows a program to split into multiple subprograms called threads that can run concurrently. Threads go through various states like new, runnable, running, blocked, and dead. There are two main ways to create threads: by extending the Thread class or implementing the Runnable interface. Threads can have different priorities that influence scheduling order. Multithreading allows performing multiple operations simultaneously to save time without blocking the user, and exceptions in one thread do not affect others.
El documento describe los pasos para crear una conexión a una base de datos MySQL desde una aplicación Java desarrollada en NetBeans. Estos pasos incluyen crear la base de datos y tablas en MySQL, configurar el driver JDBC en NetBeans, crear clases que establecen la conexión y realizan consultas, e implementar consultas de selección, actualización e inserción en la clase principal.
OCA Java SE 8 Exam Chapter 4 Methods Encapsulationİbrahim Kürce
Methods allow classes to define reusable blocks of code. They can be declared with access modifiers like public or private, return types, parameters, and exceptions. Static methods can be called without an object and are used for utility functions. Constructors initialize new objects and can call other constructors through constructor chaining. Encapsulation involves making data private and accessing it through public getters and setters to control changes to an object's state. Immutable classes cannot be modified once created.
Java 10 contains several new features including local variable type inference using the var keyword, time-based release versioning, improved support for Docker containers, and various library enhancements. It focuses on improving performance and usability. Some notable changes include local variable type inference for concise code, parallel full GC for the G1 collector to reduce latency, and application data sharing to improve startup times.
Un paquete es una colección de clases e interfaces relacionadas que puede agrupar código de forma modular. Los nombres de paquetes siguen una estructura jerárquica y las clases deben ubicarse en subdirectorios que mapean esta estructura. La variable CLASSPATH indica donde buscar los paquetes, mientras que la sentencia package incluye una clase en un paquete y la sentencia import facilita referencias a clases entre paquetes.
The document discusses threads and multithreading in Java. It defines a thread as a single sequential flow of control within a program. Multithreading allows a program to be divided into multiple subprograms that can run concurrently. Threads have various states like newborn, runnable, running, blocked, and dead. The key methods for managing threads include start(), sleep(), yield(), join(), wait(), notify(). Synchronization is needed when multiple threads access shared resources to prevent inconsistencies. Deadlocks can occur when threads wait indefinitely for each other.
This document provides an overview of threads in Java. It discusses what threads are, the different states threads can be in, how to set thread priorities, and the Thread class. It also covers the two main ways to create Java threads: by extending the Thread class or implementing the Runnable interface. Additional topics covered include thread groups, synchronization to avoid race conditions, and inter-thread communication.
This document discusses exception handling in Java. It defines what exceptions are, why they occur, and what exception handling is. It describes the advantages of exception handling and differences between exceptions and errors. It covers the exception class hierarchy and exception handling keywords like try, catch, finally, throw, and throws. It provides examples of common exception types and an example Java code demonstrating exception handling.
Threads allow multiple tasks to run concurrently within a single Java program. A thread represents a separate path of execution and threads can be used to improve performance. There are two main ways to create threads: by extending the Thread class or implementing the Runnable interface. Threads transition between different states like new, runnable, running, blocked, and terminated. Synchronization is needed to prevent race conditions when multiple threads access shared resources simultaneously. Deadlocks can occur when threads wait for each other in a circular manner.
Java is an object-oriented programming language initially developed by Sun Microsystems. It was released in 1995. Key points:
- Java can be used to develop client-side standalone applications, applets for webpages, and server-side applications.
- It introduced the Java Virtual Machine (JVM) which allows Java programs to run on any platform that supports the JVM.
- Java's use of bytecode makes it portable and able to run on any device with a JVM, earning it the label of "Write Once, Run Anywhere".
Este documento explica los diferentes tipos de restricciones en SQL, incluyendo UNIQUE, PRIMARY KEY, FOREIGN KEY, CHECK y NOT NULL. Describe cómo se usan estas restricciones para definir reglas sobre los valores permitidos en las columnas y garantizar la integridad referencial entre tablas. Incluye ejemplos de cómo aplicar estas restricciones usando las instrucciones CREATE TABLE y ALTER TABLE.
Capítulo 7 sincronización de procesos 09 01-2012ecuatareas
Este documento presenta tres algoritmos para resolver el problema de la sección crítica entre dos hilos. El Algoritmo 1 usa una variable turno compartida que indica qué hilo puede acceder a la sección crítica. El Algoritmo 2 usa una matriz de banderas para cada hilo. El Algoritmo 3 combina la variable turno y la matriz de banderas. También describe soluciones basadas en hardware como test-and-set e intercambio y el uso de semáforos para controlar el acceso a secciones críticas.
This document discusses multithreading in Java. It defines threads as pieces of code that run concurrently with other threads. It describes the life cycle of a thread as starting, running, and stopping. It also discusses how to create multithreaded programs in Java by either extending the Thread class or implementing the Runnable interface.
An interface in Java is like a class but cannot be instantiated. It defines method signatures and constant values but not method implementations. A class implements an interface by providing method bodies for the abstract methods defined in the interface. Interfaces can extend other interfaces to inherit their methods.
This presentation is about advanced multithreading and concurrency in Java. I have tried my best to explain the concepts with code. Feel free to reach me if you have any questions or concerns.
This document discusses exception handling in C++ and Java. It defines what exceptions are and explains that exception handling separates error handling code from normal code to make programs more readable and robust. It covers try/catch blocks, throwing and catching exceptions, and exception hierarchies. Finally, it provides an example of implementing exception handling in a C++ program to handle divide-by-zero errors.
The document discusses Java Sets and Maps. It describes that a Set is an unordered collection with no duplicates, while a Map maps keys to values with no duplicate keys. Common Set implementations are HashSet, TreeSet, and LinkedHashSet. Common Map implementations are HashMap and TreeMap. The document provides examples of typical operations on Sets like contains, add, remove, and iterating with iterators or enhanced for loops. It also discusses operations on Maps like put, get, remove, and iterating over the keySet, values, or entrySet.
OCA Java SE 8 Exam Chapter 1 Java Building Blocksİbrahim Kürce
The document discusses key concepts in Java including classes, objects, fields, methods, variables, primitive types, reference types, and memory management. It explains that classes are the basic building blocks in Java programs and contain fields and methods. Objects are instances of classes that exist in memory. The document also covers variable scope, default initialization, and garbage collection in Java.
Multithreading allows a program to split into multiple subprograms called threads that can run concurrently. Threads go through various states like new, runnable, running, blocked, and dead. There are two main ways to create threads: by extending the Thread class or implementing the Runnable interface. Threads can have different priorities that influence scheduling order. Multithreading allows performing multiple operations simultaneously to save time without blocking the user, and exceptions in one thread do not affect others.
El documento describe los pasos para crear una conexión a una base de datos MySQL desde una aplicación Java desarrollada en NetBeans. Estos pasos incluyen crear la base de datos y tablas en MySQL, configurar el driver JDBC en NetBeans, crear clases que establecen la conexión y realizan consultas, e implementar consultas de selección, actualización e inserción en la clase principal.
OCA Java SE 8 Exam Chapter 4 Methods Encapsulationİbrahim Kürce
Methods allow classes to define reusable blocks of code. They can be declared with access modifiers like public or private, return types, parameters, and exceptions. Static methods can be called without an object and are used for utility functions. Constructors initialize new objects and can call other constructors through constructor chaining. Encapsulation involves making data private and accessing it through public getters and setters to control changes to an object's state. Immutable classes cannot be modified once created.
Java 10 contains several new features including local variable type inference using the var keyword, time-based release versioning, improved support for Docker containers, and various library enhancements. It focuses on improving performance and usability. Some notable changes include local variable type inference for concise code, parallel full GC for the G1 collector to reduce latency, and application data sharing to improve startup times.
Un paquete es una colección de clases e interfaces relacionadas que puede agrupar código de forma modular. Los nombres de paquetes siguen una estructura jerárquica y las clases deben ubicarse en subdirectorios que mapean esta estructura. La variable CLASSPATH indica donde buscar los paquetes, mientras que la sentencia package incluye una clase en un paquete y la sentencia import facilita referencias a clases entre paquetes.
The document discusses threads and multithreading in Java. It defines a thread as a single sequential flow of control within a program. Multithreading allows a program to be divided into multiple subprograms that can run concurrently. Threads have various states like newborn, runnable, running, blocked, and dead. The key methods for managing threads include start(), sleep(), yield(), join(), wait(), notify(). Synchronization is needed when multiple threads access shared resources to prevent inconsistencies. Deadlocks can occur when threads wait indefinitely for each other.
This document provides an overview of threads in Java. It discusses what threads are, the different states threads can be in, how to set thread priorities, and the Thread class. It also covers the two main ways to create Java threads: by extending the Thread class or implementing the Runnable interface. Additional topics covered include thread groups, synchronization to avoid race conditions, and inter-thread communication.
This document discusses exception handling in Java. It defines what exceptions are, why they occur, and what exception handling is. It describes the advantages of exception handling and differences between exceptions and errors. It covers the exception class hierarchy and exception handling keywords like try, catch, finally, throw, and throws. It provides examples of common exception types and an example Java code demonstrating exception handling.
Threads allow multiple tasks to run concurrently within a single Java program. A thread represents a separate path of execution and threads can be used to improve performance. There are two main ways to create threads: by extending the Thread class or implementing the Runnable interface. Threads transition between different states like new, runnable, running, blocked, and terminated. Synchronization is needed to prevent race conditions when multiple threads access shared resources simultaneously. Deadlocks can occur when threads wait for each other in a circular manner.
Java is an object-oriented programming language initially developed by Sun Microsystems. It was released in 1995. Key points:
- Java can be used to develop client-side standalone applications, applets for webpages, and server-side applications.
- It introduced the Java Virtual Machine (JVM) which allows Java programs to run on any platform that supports the JVM.
- Java's use of bytecode makes it portable and able to run on any device with a JVM, earning it the label of "Write Once, Run Anywhere".
Este documento explica los diferentes tipos de restricciones en SQL, incluyendo UNIQUE, PRIMARY KEY, FOREIGN KEY, CHECK y NOT NULL. Describe cómo se usan estas restricciones para definir reglas sobre los valores permitidos en las columnas y garantizar la integridad referencial entre tablas. Incluye ejemplos de cómo aplicar estas restricciones usando las instrucciones CREATE TABLE y ALTER TABLE.
Capítulo 7 sincronización de procesos 09 01-2012ecuatareas
Este documento presenta tres algoritmos para resolver el problema de la sección crítica entre dos hilos. El Algoritmo 1 usa una variable turno compartida que indica qué hilo puede acceder a la sección crítica. El Algoritmo 2 usa una matriz de banderas para cada hilo. El Algoritmo 3 combina la variable turno y la matriz de banderas. También describe soluciones basadas en hardware como test-and-set e intercambio y el uso de semáforos para controlar el acceso a secciones críticas.
El documento trata sobre hilos (threads) en Java. Explica que un hilo es un flujo de ejecución independiente que puede ejecutarse en paralelo a otros. Detalla la clase Thread de Java y cómo crear e implementar hilos heredando de Thread o implementando la interfaz Runnable. También cubre conceptos como el ciclo de vida de los hilos y la sincronización.
Este documento trata sobre la programación concurrente. Explica que la programación concurrente permite la ejecución simultánea de procesos para aprovechar mejor los recursos del hardware. También describe los beneficios de la programación concurrente como la velocidad de ejecución y la solución de problemas inherentemente concurrentes como sistemas de control, aplicaciones web y simulaciones. Finalmente, analiza conceptos como concurrencia, procesos, comunicación y sincronización, que son fundamentales en la programación concurrente.
Cleft sentences are used to focus on or emphasize a particular part of a sentence by introducing it with a relative clause. Some examples include "The reason why I've come is to discuss my future with you" and "The thing that impresses me more than anything else is your generosity." Cleft sentences can also be used to specify the place or time of an event, such as "The place where the jewels are hidden is under the floor at 23 Robin Hood Road, Epping" and "The day (when) the Second World War ended in Europe was 7 May 1945."
The document provides examples of telling time in hours, minutes and periods of the day (am and pm). It lists times such as "three o'clock", "twenty to one", "ten past ten", and accompanies each with the question "What time is it?". It then prompts the reader to choose the correct clock face for times including "half past five", "a quarter past nine", and "midday".
The document is a short article by Elena Vazquez about the time just before 5pm. It discusses how the day is coming to an end and people are finishing up their work for the day and getting ready to go home after a long day.
El documento trata sobre multithreading en Java. Explica conceptos como crear hilos extendiendo la clase Thread o implementando la interfaz Runnable, y controlar hilos mediante métodos como start(), sleep(), yield() y join(). También cubre temas como el ciclo de vida de los hilos, sincronización, grupos de hilos y el uso de la clase Timer.
Este documento introduce los conceptos básicos de la programación multihilo en Java, incluyendo la creación de hilos que extienden la clase Thread o implementan la interfaz Runnable, los diferentes estados de un hilo, y cómo sincronizar el acceso a recursos compartidos para evitar errores. También explica la planificación de hilos y la asignación de prioridades.
Este módulo cubre los hilos en Java, los cuales permiten que un programa realice múltiples tareas al mismo tiempo. Se explica cómo crear hilos, controlar su ejecución y proteger los datos compartidos. Se definen los hilos, sus estados de ciclo de vida y métodos como wait(), notify() y synchronized. También se describen formas comunes de crear hilos como implementando Runnable o extendiendo Thread.
La clase Thread permite crear hilos de ejecución concurrentes en Java. Para crear un hilo, una clase debe extender Thread y redefinir el método run(), el cual especifica la tarea concurrente. Se inicia un hilo mediante el método start(), el cual invoca a run() y devuelve el control. Los hilos comparten los recursos de un proceso y pasan por diferentes estados como nuevo, ejecutable y muerto.
El documento describe los conceptos de threads y programación multithread en Java. Específicamente, explica que (1) los threads comparten recursos y permiten la ejecución concurrente de tareas, a diferencia de los procesos que son independientes, y (2) Java permite la creación explícita de threads para lograr mayor flexibilidad y rendimiento en aplicaciones.
El documento explica conceptos relacionados con hilos (threads) en Java. Define un hilo como un flujo de ejecución secuencial dentro de un proceso. Explica cómo crear e implementar hilos, así como los diferentes estados por los que pasan los hilos durante su ciclo de vida. También cubre temas como la sincronización de hilos y el uso de grupos de hilos.
Un thread es un proceso ligero o tarea que se ejecuta dentro de un programa. Pueden existir múltiples threads ejecutándose simultáneamente. Los threads comparten los recursos del programa y cada uno tiene un flujo secuencial de control. Existen dos métodos para crear threads en Java: extendiendo la clase Thread e implementando la interfaz Runnable.
Un thread es un proceso ligero o tarea que se ejecuta dentro de un programa. Pueden existir múltiples threads ejecutándose simultáneamente. Los threads comparten los recursos del programa y cada uno tiene un flujo secuencial de control. Existen dos métodos para crear threads en Java: extendiendo la clase Thread e implementando la interfaz Runnable.
La multitarea permite la ejecución simultánea de varias tareas compartiendo un único procesador, mientras que el multiproceso requiere de múltiples procesadores. Java permite la programación multitarea a través de hilos implementados con la clase Thread o la interfaz Runnable. El framework de concurrencia de Java simplifica el desarrollo de aplicaciones multitarea a través de estructuras de datos concurrentes, variables atómicas, bloqueos y otras utilidades.
Un hilo es una tarea que puede ejecutarse simultáneamente con otras tareas. Los hilos comparten recursos como memoria y archivos con otros hilos dentro de un mismo proceso, pero cada hilo tiene su propio contador de programa y estado de CPU. Los hilos pueden cambiar entre estados como ejecución, listo y bloqueado.
Este documento describe los conceptos básicos de los hilos en Java, incluyendo las clases relacionadas como Thread, Runnable y ThreadGroup. Explica cómo crear hilos extendiendo la clase Thread o implementando la interfaz Runnable, y cubre temas como el estado, control, planificación y sincronización de los hilos.
Este documento presenta una guía sobre el uso de hilos en Java. Explica que un hilo es un flujo de ejecución dentro de un proceso y que Java soporta hilos a través de la clase Thread y la interfaz Runnable. También describe el ciclo de vida de un hilo, incluyendo los estados new, runnable, not running y dead. Además, cubre temas como prioridad de hilos, métodos sincronizados y el uso de la clase ThreadGroup.
Este documento trata sobre la programación concurrente, que implica la ejecución simultánea de múltiples tareas o procesos. Explica las diferencias entre programa y proceso, y cómo la concurrencia surge cuando dos o más procesos interactúan de forma simultánea, ya sea en un solo procesador o en varios. También describe características clave de los sistemas concurrentes como el orden parcial de ejecución y el comportamiento indeterminista.
El documento describe conceptos básicos de programación concurrente y paralela en Java como hilos, sincronización y prioridades. Explica que los hilos son unidades básicas de ejecución que comparten memoria dentro de un proceso y que Java se enfoca más en hilos que en procesos. También cubre temas como la creación de hilos, su planificación, sincronización para evitar problemas de acceso a recursos compartidos y métodos para controlar su ejecución.
Este documento presenta una guía para una práctica de laboratorio sobre procesos concurrentes o hilos para diseñar un servidor web. Explica conceptos como hilos, estados de un proceso concurrente, la clase Thread en Java y sus métodos. También describe cómo construir un hilo mediante la creación de una nueva clase que herede de Thread y redefina el método run(). Finalmente, propone como ejercicio crear dos hilos para visualizar imágenes y letras de forma concurrente.
Este documento describe los conceptos básicos de los hilos en Java, incluyendo las clases relacionadas como Thread, Runnable y ThreadGroup. Explica cómo crear e implementar hilos en Java y cómo controlar y sincronizar su estado y ejecución. También cubre temas como la planificación, prioridad y agrupamiento de hilos.
Este documento describe conceptos clave relacionados con procesos cooperativos y comunicación entre procesos en sistemas operativos. Explica que los procesos pueden ser independientes o cooperativos si comparten datos u objetivos. También describe varios métodos para la comunicación entre procesos, como la comunicación directa e indirecta a través de mensajes y buzones. Además, aborda conceptos como la sincronización, los hilos de usuario y kernel, y soluciones para garantizar la exclusión mutua en las secciones críticas.
Este material didáctico fue desarrollado para la asignatura de Tópicos Avanzados de Programación, del plan SCD-1027 2016 de Ing. En Sistemas Computacionales
Este documento presenta información sobre programación concurrente utilizando hilos. Explica conceptos como hilos, clases Thread y Monitor, y métodos para la sincronización de hilos como lock, wait y pulse. También presenta ejemplos de código para crear y manejar hilos, y describe problemas como el problema de los filósofos comensales que requieren sincronización de hilos.
Este documento resume la Unidad IV de programación concurrente (multihilo). Explica conceptos clave como hilos, estados de hilos, programas de flujo único, creación y control de hilos, y sincronización de hilos a través del uso de métodos synchronized y declaraciones synchronized.
El documento describe las interfaces gráficas de usuario (GUI) en Java. Explica que las GUI ofrecen ventanas, botones y otros elementos visuales con los que los usuarios interactúan. La API de Java proporciona clases para crear GUI, incluyendo AWT y Swing. Swing reemplaza muchas clases AWT y proporciona nuevos componentes como árboles y tablas. Las aplicaciones GUI se construyen usando contenedores, componentes y manejadores de eventos.
El documento habla sobre herencia y polimorfismo en programación orientada a objetos en Java. Explica que la herencia permite que una clase herede atributos y métodos de otra clase y extienda su funcionalidad. También cubre clases abstractas, interfaces, y cómo el polimorfismo permite tratar objetos de subclases como si fueran de la clase base.
Este documento proporciona una introducción al desarrollo de componentes EJB. Explica que los EJBs son componentes distribuidos que permiten separar la lógica de negocio de los servicios proporcionados por el contenedor, como comunicaciones en red, transacciones y persistencia. También describe los tres tipos principales de EJBs, el proceso de creación de un EJB que incluye interfaces home y remotas y la clase bean, y cómo empaquetar y desplegar un EJB en un contenedor.
Tema 16 acceso a base de datos usando jpa por gioRobert Wolf
1) El documento describe el acceso a bases de datos usando JPA, una capa de software que reduce la tarea de conversión entre objetos y datos relacionales. 2) JPA mapea objetos a tablas mediante anotaciones y permite operaciones CRUD. 3) Se explican diferentes tipos de mapeo como uno a uno, muchos a uno, herencia y entidades.
Tema 15 aplicaciones de dos capas por gioRobert Wolf
Una aplicación de dos capas separa el código de la aplicación del sistema de administración de la base de datos. En una aplicación de dos capas, el cliente contiene la interfaz de usuario y lógica del negocio, mientras que el servidor contiene un administrador de bases de datos. La API JDBC de Java proporciona una forma estándar para que un cliente Java se comunique con diferentes administradores de bases de datos a través de un protocolo.
El documento describe cómo se representan y manipulan las imágenes en Java. Las imágenes se representan mediante las clases Image y BufferedImage, donde BufferedImage permite acceder directamente a los datos de los pixeles. Un objeto BufferedImage contiene un ColorModel que interpreta los colores de los pixeles y un Raster que almacena y organiza los datos de los pixeles. Las imágenes se pueden crear, dibujar, recortar y guardar usando métodos de estas clases.
Este documento describe la API de Java para gráficas. Explica que la clase Graphics2D es la clase central de la API 2D de Java y se encarga de representar figuras, texto e imágenes en dispositivos de salida. También describe los pasos involucrados en el proceso de presentación gráfica, incluyendo la transformación, entramado y composición de elementos gráficos.
Tema 11 expresiones regulares en java por gioRobert Wolf
Una expresión regular es un patrón que define un conjunto de cadenas y se puede usar para comparar y reemplazar texto. Las expresiones regulares incluyen caracteres, clases de caracteres, cuantificadores, metacaracteres y operadores lógicos que permiten crear patrones complejos. Las expresiones regulares se usan comúnmente para analizar datos como archivos, cadenas de entrada y formularios.
Las clases abstractas y las interfaces en Java sirven para definir comportamientos comunes en clases sin proporcionar una implementación completa. Las clases abstractas pueden contener métodos abstractos y métodos concretos, mientras que las interfaces sólo contienen métodos abstractos. Las subclases de una clase abstracta deben implementar los métodos abstractos, mientras que las clases que implementan una interfaz deben implementar todos sus métodos.
El documento describe los sistemas de archivos y la clase File en Java. Un sistema de archivos organiza los datos de una forma eficiente y está adaptado a las características del dispositivo de almacenamiento. La clase File proporciona una abstracción de los nombres de archivo y rutas que oculta las diferencias entre sistemas operativos al programador.
El documento describe las pruebas unitarias en Java. Explica que es responsabilidad del programador probar su código para asegurarse de que funcione correctamente. También describe cómo se pueden realizar pruebas manuales creando clases de prueba que ejecuten los métodos con diferentes valores de entrada y validen los resultados. Finalmente, introduce el marco JUnit, el cual automatiza el proceso de pruebas a través de anotaciones que indican qué métodos son pruebas y validan sus resultados.
Tema 9 aplicaciones de dos capas por gioRobert Wolf
Una aplicación de dos capas separa el código de la aplicación del sistema de administración de la base de datos. En Java, la API JDBC proporciona una interfaz estándar para que un cliente escrito en Java se comunique con administradores de bases de datos. La API JDBC consta de interfaces y clases que representan conexiones, sentencias SQL y resultados de consultas. Las aplicaciones de dos capas encapsulan esta funcionalidad en clases como Conexión y Tabla para establecer conexiones y ejecutar operaciones SQL de forma sencilla.
El documento describe los conceptos de archivos y flujos en Java. Explica que los archivos permiten almacenar datos de forma persistente en dispositivos de memoria secundaria y que los flujos proveen una interfaz común para acceder a archivos independientemente de su tipo. También describe las clases principales en Java para trabajar con archivos de caracteres de acceso secuencial como Reader, Appendable y las interfaces relacionadas.
Tema 8 desarrollo de aplicaciones en java por gioRobert Wolf
Este documento describe el desarrollo de una aplicación en Java utilizando diagramas de clases y secuencia. Explica cómo un diagrama de secuencia representa la interacción entre los componentes de una aplicación para lograr un caso de uso. Luego presenta un ejemplo de una aplicación de música que permite agregar canciones, mostrando el diagrama de secuencia y código Java correspondiente a este caso de uso.
1) El documento describe los componentes y conceptos clave para crear interfaces gráficas de usuario en Java como contenedores, manejadores de diseño, componentes activos y de texto, y programación por eventos. 2) También presenta un ejemplo de interfaz gráfica para una aplicación de música que ilustra el uso de estos conceptos. 3) La interfaz incluye ventanas, cuadros de diálogo, tablas, menús y captura de datos para administrar un catálogo de canciones.
Tema 7 desarrollo de aplicaciones en java - lsia por gioRobert Wolf
Este documento describe el desarrollo de aplicaciones en Java utilizando diagramas de secuencia. Explica cómo los diagramas de secuencia describen el orden en que ocurren las invocaciones de métodos entre objetos para implementar casos de uso. Luego presenta un ejemplo de una aplicación de música que permite agregar y actualizar canciones, mostrando el código Java que implementa estos casos de uso siguiendo el diagrama de secuencia correspondiente. Finalmente, describe las clases principales como Control, Conversiones y Tabla que interactúan para llevar a cabo las funcional
1) El documento describe los componentes principales de Java para crear interfaces gráficas de usuario, incluyendo contenedores, manejadores de diseño y componentes. 2) Explica el modelo de programación por eventos en Java y cómo los componentes generan y manejan eventos. 3) Proporciona un ejemplo de interfaz gráfica para una aplicación de música que ilustra el uso de estos componentes.
El documento describe las colecciones en Java. Explica que una colección agrupa múltiples elementos y que Java proporciona un marco de colecciones con interfaces y clases para representar y manipular colecciones de manera genérica. Describe los métodos principales de la interfaz Collection para agregar, remover y consultar elementos, y explica cómo recorrer colecciones usando iteradores o ciclos foreach. También define listas como colecciones ordenadas que permiten acceder a elementos por su índice.
El documento describe los arreglos y cadenas en Java. Explica que un arreglo es una lista de variables del mismo tipo almacenadas en memoria contigua, y cada elemento puede accederse por su posición. Describe arreglos unidimensionales, bidimensionales y tridimensionales, y cómo declarar, crear, inicializar y acceder a los elementos de un arreglo unidimensional. También cubre el uso de arreglos con métodos y el ciclo for-each.
Tema 5 arreglos y cadenas - lsia por gioRobert Wolf
Este documento describe los arreglos y cadenas en Java. Explica que un arreglo es una lista de variables del mismo tipo almacenadas en memoria contigua, y cada elemento puede accederse por su posición. Detalla los tipos de arreglos como unidimensionales, bidimensionales y tridimensionales. Luego profundiza en los arreglos unidimensionales, incluyendo cómo declararlos, crearlos, inicializarlos, acceder a sus elementos, y usarlos con métodos. Finalmente, presenta un ejemplo de clases para almacenar datos de música y pel
1. ITSON Manuel Domitsu Kono
Tema 12
Hilos en Java
Procesos e Hilos
En la programación concurrente, hay dos unidades básicas de ejecución: procesos
e hilos. En el lenguaje de programación Java, la programación concurrente está
más relacionada con los hilos. Sin embargo, los procesos también son
importantes.
Un Proceso es un ambiente de ejecución autocontenido. Por lo general tiene
recursos de ejecución completos y privados, en particular cada proceso tiene su
propio espacio de memoria.
A veces se ve a los procesos como sinónimo de programas o aplicaciones. Sin
embargo, una aplicación puede ser un conjunto de procesos cooperativos. Para
facilitar la comunicación entre procesos, la mayoría de los sistemas operativos
soportan recursos de Comunicación entre Procesos, IPC, como tubos y sockets.
IPC no sólo se usa para comunicar procesos en un solo sistema sino procesos en
diferentes sistemas.
Un Hilo, llamado a veces proceso ligero, provee también un ambiente de
ejecución. Pero crear un nuevo hilo requiere de menos recursos que crear un
nuevo proceso.
Los hilos existen dentro de los procesos – cada proceso tiene al menos un hilo. Un
proceso con un solo hilo tiene las siguientes propiedades:
• El proceso empieza su ejecución en un punto bien conocido. En los
programas como C, C++ o Java el proceso empieza su ejecución en la
primera sentencia del método main().
• La ejecución de las sentencias sigue una secuencia predefinida
completamente ordenada para un conjunto de entradas.
• Durante la ejecución, el proceso tiene acceso a ciertos datos. En Java hay
tres tipos de datos a los que un proceso puede acceder: variables locales
que se encuentran en la pila del hilo. Variables de instancia que se accesan
mediante referencias y variables estáticas que se acceden mediante clases
o referencias a objetos.
2. 430 Hilos en Java
ITSON Manuel Domitsu Kono
En la figura 11.1 se ilustra un ejemplo de un sistema multitarea, en el cual hay
varias aplicaciones en ejecución. Cada uno de ellos con un solo hilo de ejecución.
En este caso tenemos varios procesos ejecutándose simultáneamente.
Figura 12.1
Aunque para el usuario, los procesos parecen estar ejecutándose
simultáneamente, esto solo puede ocurrir en un sistema con varios procesadores
o con un procesador con varios núcleos de ejecución. En el caso de un sistema
con un solo procesador mononúcleo, la apariencia de ejecución simultánea se
logra compartiendo el procesador entre los diferentes procesos asignándole a
cada uno de ellos una ranura de tiempo y cambiando a ejecutar otro proceso
cuando el tiempo de la ranura se ha agotado.
En un sistema multitarea que soporta multihilos, los hilos comparten los recursos
de un proceso, incluyendo la memoria y los archivos abiertos. Esto hace la
comunicación eficiente pero potencialmente problemática. En este caso cada
proceso puede tener uno o más hilos. Los diferentes procesos y sus hilo pueden
ejecutarse simultáneamente en forma real o aparente, dependiendo del número de
procesadores o núcleos.
En un proceso, los hilos múltiples tienen las siguientes propiedades:
• Cada hilo empieza su ejecución en un punto bien conocido. Para alguno de
esos hilos ese punto es la primera sentencia del método main(). Para el
resto de los hilos, el programador decide ese punto al codificar el hilo.
• Cada hilo ejecuta su código desde su punto inicial en una forma ordenada y
predefinida para un conjunto de entradas.
• Cada hilo ejecuta su código independientemente de los otros hilos en el
programa. Si se requiere existen mecanismos para que los hilos cooperen
entre sí.
• Los hilos aparentar ejecutar con cierto grado de simultaneidad.
• Los hilos tienen acceso a varios tipos de datos. Cada hilo tiene sus propias
variables locales. Los hilos pueden compartir las variables de instancia. Los
hilos comparten en forma automática a las variables estáticas.
3. Tema 12 Hilos en Java 431
ITSON Manuel Domitsu Kono
En la figura 12.2 se ilustra un ejemplo de un sistema multitarea, en el cual hay
varias aplicaciones en ejecución. Cada uno de ellos puede tener varios hilos de
ejecución. En este caso, uno de esos procesos es la máquina virtual de java.
Figura 12.2
La ejecución multihilo es una característica esencial de la plataforma de Java.
Cada aplicación tiene al menos un hilo o varias si se cuentan los hilos del sistema
que administran la memoria y el manejo de las señales. Pero desde el punto de
vista del programador se empieza con un hilo, llamado el hilo principal. Este hilo
tiene la habilidad de crear hilos adicionales como se verá más adelante.
La API de Java para Hilos
Para comprender el funcionamiento de un programa multihilo veamos primero un
programa con un solo hilo de ejecución. Considere el el siguiente programa
formado por dos clases:
Hilo.java
public class Hilo {
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(i + ": Hola");
}
}
}
4. 432 Hilos en Java
ITSON Manuel Domitsu Kono
Prueba.java
public class Prueba {
public static void main(String[] args) {
Hilo hilo = new Hilo();
hilo.run();
}
}
En la figura 12.3 se muestra el comportamiento del programa con el tiempo. En
este caso como sólo hay un hilo de ejecución las sentencias se ejecutan una
después de la otra. No hay concurrencia.
Figura 12.3
Para hacer que el método run() ejecute en paralelo con el método main() y
otros métodos de la clase Prueba, hay que modificar la clase Hilo para que sea
ejecutado por un nuevo hilo. Para ello nuestra clase Hilo deberá heredar de la
clase Thread. Como se muestra en el siguiente código:
Hilo.java
public class Hilo extends Thread {
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(I + ": Hola");
}
}
}
También debemos modificar a la clase que invoca a la clase Hilo para que en
lugar de invocar a su método run() invoque a su método start().
Prueba.java
5. Tema 12 Hilos en Java 433
ITSON Manuel Domitsu Kono
public class Prueba {
public static void main(String[] args) {
Hilo hilo = new Hilo();
hilo.start();
}
}
El método start() es quien crea otro hilo de ejecución. Este hilo, después de un
proceso de inicialización invoca al método run(). Este mismo hilo, cuando el
método run() completa se encarga de ños detalles de terminación del hilo. El
método start() del hilo original regresa inmediatamente, por lo que el método
run() ejecutará en el nuevo hilo al mismo tiempo que el método start()
regresa en el primer hilo como se muestra en la figura 12.4.
Figura 12.4
La clase Thread forma parte de la API de Java para hilos. Parte de esa API se
muestra en la figura 12.5.
Tabla 12.1 Atributos de la Clase Thread
public static final int MAX_PRIORITY
La máxima prioridad que puede tener un hilo
public static final int MIN_PRIORITY
La mínima prioridad que puede tener un hilo
public static final int NORM_PRIORITY
La prioridad por ausencia, que puede tener un hilo
6. 434 Hilos en Java
ITSON Manuel Domitsu Kono
Figura 12.4
Tabla 12.2 Métodos de la Clase Thread.
public Thread()
public Thread(Runnable target)
public Thread(Runnable target, String name)
public Thread(String name)
Crean nuevos hilos. El parámetro target denota el objeto del cual se ejecuta el método run().El
valor por omisión es null. El parámetro name establece el nombre del nuevo hilo. El valor
prestablecido es “Thread-“n, donde n es un entero consecutivo.
public void start()
Hace que este hilo inicie su ejecución; La máquina virtual de Java llama al método run() de este
hilo. Como resultado hay dos hilos ejecutándose concurrentemente. El hilo actual (que regresa de
la llamada al método start() y el otro hilo (que ejecuta su método run()).
Es ilegal iniciar un hilo más de una vez. En particular un hilo no puede reiniciarse una vez que
completa su ejecución.
Lanza:
IllegalThreadStateException – Si el hilo ya ha sido iniciado.
public void run()
Si este hilo fue construido usando un objeto Runnable diferente, entonces se invoca al método
run() del objeto. De otra forma, el método no hace nada y regresa.
7. Tema 12 Hilos en Java 435
ITSON Manuel Domitsu Kono
Hilos Usando la Interfaz Runnable
Hay ocasiones en que crear un hilo heredando de la clase Thread no es
conveniente. Por ejemplo, si la clase que deseamos que sea un hilo, es una
subclase, no podemos hacer que herede de la clase Thread ya que una clase
sólo puede heredar de una clase. En estos casos, en vez de hacer que la clase
herede de la clase Thread haremos que la clase implemente la interfaz
Runnable, como se muestra en el siguiente código:
HiloRunnable.java
public class HiloRunnable implements Runnable {
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(i + ": Hola desde la clase Hilo");
}
}
}
Una clase que implemente la interfaz debe implementar el método run(). Sin
embargo para crear un nuevo hilo no es suficiente con crear una instancia de la
clase que implementa la interfaz Runnable e invocar a su método start() ya
que la clase no hereda de la clase Thread y no tiene el método start(). En
lugar de ello crearemos un nuevo hilo y le pasaremos al constructor de la clase
Thread la instancia de la clase que implementa la interfaz Runnable, como se
muestra en el siguiente código:
PruebaHiloRunnable.java
public class PruebaHiloRunnable {
public static void main(String[] args) {
Runnable hiloRunnable = new Hilo();
Thread hilo = new Thread(hiloRunnable);
hilo.start();
}
}
La razón para pasarle un objeto Runnable al constructor de la clase Thread es
para que el hilo tenga acceso al método run() del objeto Runnable para que lo
ejecute. El método start() del hilo llama al método run() de la clase Thread
ya que no fue sobrescrito, que a su vez llama al método run()del objeto
Runnable ya que el método run() por ausencia de la clase Thread tiene la
forma:
public void run() {
if (target != null) target.run();
}
8. 436 Hilos en Java
ITSON Manuel Domitsu Kono
Donde target es el objeto Runnable que le pasamos al constructor del hilo. Así
que el hilo empieza la ejecución de su método run() quien inmediatamente llama al
método run() del objeto Runnable.
Suspender y Parar un Hilo
La ejecución de un hilo puede ser suspendida temporalmente, invocando a su método
sleep(), tabla 12.3.
Tabla 12.3 Métodos de la Clase Thread. Cont.
public static void sleep(long millis) throws InterruptedException
public static void sleep(long millis, int nanos)
throws InterruptedException
Hace que el hilo, actualmente en ejecución se duerma (cese temporalmente su ejecución) por el
número de milisegundos (más el número de nanosegundos, en el caso del segundo método) dado
por el parámetro, sujeto a la precisión y exactitud de los temporalizadores y el programador
tareas. El hilo no pierde la propiedad de ninguno de sus monitores.
El valor del parámetro nanos debe estar en el rango de 0 – 999999 nanosegundos.
Lanza:
InterruptedException – Si cualquier hilo ha interrumpido este hilo. El estado
interrumpido del hilo actual se limpia cuando se lanza esta excepción.
IllegalArgumentException – Si el valor de millis es negativo o el valor de nanos
no está en el rango de 0 – 999999 nanosegundos.
public final boolean isAlive()
Checa si el hilo está vivo. Un hilo está vivo si ha sido iniciado y no ha muerto.
El siguiente código muestra el uso del método sleep() de la clase Thread para
implementar un hilo que ejecuta una tarea periódicamente. En este ejemplo, el
método suspende la ejecución del hilo por 1000 ms por lo que el ciclo despliega el
mensaje aproximadamente cada 1 s mientras se repita el ciclo.
Este código también ilustra la forma de parar un hilo. Para parar un hilo hay que
hacer que su método run() termine su ejecución y regrese. Para lograr eso en la
clase principal hacemos que la variable vivo tome el valor de falso, lo que hará que
el ciclo termine y termine también el método run(). También en la clase principal
le asignamos a la referencia al hilo, temporizador, el valor de null para que el
recolector de basura destruya al objeto y libere los recursos que el hilo tenía
asignados.
Temporizador.java
public class Temporizador extends Thread {
public volatile boolean vivo;
public Temporizador() {
vivo = true;
9. Tema 12 Hilos en Java 437
ITSON Manuel Domitsu Kono
}
public void run() {
while (vivo) {
try {
System.out.println("Despierto");
sleep(1000);
} catch (Exception e) {
}
}
}
}
PruebaTemporizador.java
public class PruebaTemporizador {
public static void main(String[] args) {
Temporizador temporizador = new Temporizador();
temporizador.start();
try {
Thread.sleep(10000);
}
catch(InterruptedException ie) {
System.out.println(ie.getMessage());
}
temporizador.vivo = false;
temporizador = null;
}
}
El ciclo de Vida de un Hilo
En la figura 12.5 muestra el ciclo de vida de un hilo. Hay un periodo de tiempo
después de que se invoca al método start() antes de que la máquina virtual de
Java pueda arrancar al hilo. En forma similar, cuando un hilo regresa de su
método run(), hay un periodo de tiempo antes que la máquina virtual de Java
pueda liberar los recursos ocupados por el hilo. Este atraso ocurre por que toma
tiempo arrancar o terminar un hilo; luego hay un tiempo de transición entre el
estado de ejecución y el estado de parado de un hilo como se muestra en la figura
12.5.
10. 438 Hilos en Java
ITSON Manuel Domitsu Kono
Figura 12.5
Para saber si un hilo ya ha arrancado o si ya terminado podemos llamar al método
isAlive(). Por ejemplo, en el siguiente código, nos aseguramos que el hilo ya
haya terminado antes de liberar los recursos que se le hayan asignado:
PruebaTemporizador.java
public class PruebaTemporizador {
public static void main(String[] args) {
Temporizador temporizador = new Temporizador();
temporizador.start();
try {
Thread.sleep(10000);
}
catch(InterruptedException ie) {
System.out.println(ie.getMessage());
}
temporizador.vivo = false;
while (temporizador.isAlive()) {
try {
Thread.sleep(100);
} catch (InterruptedException ie) {
System.out.println(ie.getMessage());
}
}
temporizador = null;
}
}
Unión de Hilos
En el ejemplo anterior usamos los métodos isAlive() y sleep() de un hilo
para esperar a que el hilo termine su ejecución antes de liberar los recusos
11. Tema 12 Hilos en Java 439
ITSON Manuel Domitsu Kono
asignados al hilo. Hay otros métodos en la API de Java que son más adecuados
para esta tarea. A este acto de esperar se le conoce como una unión de hilos. Nos
estamos uniendo con el hilo creado previamente. Para unirnos con un hilo
podemos usar el método join(), tabla 12.4.
Tabla 12.4 Métodos de la Clase Thread. Cont.
public final void join()throws InterruptedException
Espera a que este hilo muera.
Lanza:
InterruptedException – Si cualquier hilo ha interrumpido este hilo. El estado
interrumpido del hilo actual se limpia cuando se lanza esta excepción.
public final void join(long millis)throws InterruptedException
public final void join(long millis, int nanos)throws InterruptedException
Espera a que este hilo muera cuando mucho el número de milisegundos (más el número de
nanosegundos, en el caso del segundo método) dado por el parámetro. En el primer método, un
valor del parámetro de 0 significa esperar por siempre.
El valor del parámetro nanos debe estar en el rango de 0 – 999999 nanosegundos.
Lanza:
InterruptedException – Si cualquier hilo ha interrumpido este hilo. El estado
interrumpido del hilo actual se limpia cuando se lanza esta excepción.
IllegalArgumentException – Si el valor de millis es negativo o el valor de nanos
no está en el rango de 0 – 999999 nanosegundos.
El siguiente código ilustra el uso del método join() para esperar que un hilo
termine su ejecución:
PruebaTemporizador.java
public class PruebaTemporizador {
public static void main(String[] args) {
Temporizador temporizador = new Temporizador();
temporizador.start();
try {
Thread.sleep(10000);
}
catch(InterruptedException ie) {
System.out.println(ie.getMessage());
}
temporizador.vivo = false;
try {
temporizador.join();
} catch (InterruptedException ie) {
System.out.println(ie.getMessage());
}
12. 440 Hilos en Java
ITSON Manuel Domitsu Kono
temporizador = null;
}
}
Tabla 12.5 Otros Métodos de la Clase Thread. Cont.
public final String getName()
Regresa el nombre de este hilo.
public final void setName(String name)
Cambia el nombre de este hilo por el valor del parámetro.
Lanza:
SecurityException – Si el hilo actual no puede modificar el nombre de este hilo.
public static Thread currentThread()
Regresa una referencia al hilo actual en ejecución.
public static int enumerate(Thread[] tarray)
Copia en el arreglo del parámetro todos los hilos activos.
Regresa:
El número de hilos colocados en el arreglo.
Lanza:
SecurityException – Si el hilo actual no puede modificar el nombre de este hilo.
public static int activeCount()
Regresa el número de hilos actives.
public void interrupt()
Interrumpe este hilo.
Si este hilo está bloqueado en una invocación de los métodos wait() de la clase Object o de
los métodos join() o sleep() de esta clase, entonces su estado interrumpido se limpia y
recibirá una excepción del tipo InterruptedException. De otra manera el estado interrumpido
se establecerá.
Lanza:
SecurityException – Si el hilo actual no puede modificar este hilo.
public static boolean interrupted()
Prueba si el hilo actual ha sido interrumpido. El método limpia el estado interrumpido del hilo. En
otras palabras, si este método se llama dos veces en consecutivas, la segunda llamada, regresará
falso (a menos que el hilo actual sea interrumpido de nuevo, después de que la primera llamada
haya limpiado su estado interrumpido y antes de que la segunda llamada lo inspeccione.
public boolean isInterrupted()
Prueba si el hilo actual ha sido interrumpido. El método no modifica el estado interrumpido del hilo.
public final int getPriority()
Regresa la prioridad de este hilo.
13. Tema 12 Hilos en Java 441
ITSON Manuel Domitsu Kono
Tabla 12.5 Otros Métodos de la Clase Thread. Cont.
public final void setPriority(int newPriority)
Cambia la prioridad de este hilo.
Lanza:
IllegalArgumentException – Si la prioridad no está en el rango de MIN_PRIORITY a
MAX_PRIORITY.
Throws:
IllegalArgumentException - If the priority is not in the range MIN_PRIORITY to
MAX_PRIORITY.
SecurityException – Si el hilo actual no puede modificar este hilo.
public static void yield()
Hace que el hilo en ejecución actualmente, haga una pausa temporal y permita que otro hilo
ejecute.
Sincronización
Al compartir datos entre varios hilos puede ocurrir una situación llamada
condición de carrera entre dos hilos intentando acceder al mismo dato a más o
menos al mismo tiempo. Para ilustrar el problema veamos el siguiente problema:
Suponga que se desea implementar una aplicación para un cajero automático. La
primera tarea es diseñar e implementar el caso de uso que permite a un usuario
retirar efectivo de un cajero. El primer intento de algoritmo puede ser:
1. Verificar que el usuario tenga suficiente efectivo en su cuenta para cubrir el
retiro. Si no lo tiene ir al paso 4.
2. Restar la cantidad a retirar de la cuenta del usuario
3. Entregar el dinero al usuario
4. Imprimir el recibo del usuario.
La implementación del algoritmo podría ser la siguiente:
public class CajeroAutomatico extends Cajero {
public void retirar(float cantidad) {
Cuenta c = getCuenta();
if(c.deducir(cantidad))
entregar(cantidad);
imprimirRecibo();
}
Cuenta getCuenta() {
...
}
void entragar(float cantidad) {
...
14. 442 Hilos en Java
ITSON Manuel Domitsu Kono
}
void imprimirRecibo() {
...
}
}
public class Cuenta {
prívate float total;
public boolean deducir(float t) {
if(t <= total) {
total -= t;
return true;
}
return false;
}
}
La implementación parece funcionar hasta que dos personas que tengan acceso a
la misma cuenta (cuentas mancomunadas). Un día un esposo y su esposa (por
separado) deciden vaciar la cuenta y por coincidencia lo intentan al mismo
tiempo. En este caso tenemos una condición de carrera: si los dos usuarios retiran
del banco al mismo tiempo, haciendo que los métodos se llamen al mismo tiempo,
es posible que los dos cajeros confirmen que la cuenta tiene suficiente dinero y se
los entregue a ambos usuarios. Lo que ocurre es que dos hilos acceden a la base
de datos de la cuenta al mismo tiempo.
La condición de carrera ocurre porque la acción de verificar la cuenta y cambiar su
estado no es una operación atómica. El hilo del esposo y el hilo de la esposa
compiten por la cuenta:
1. El hilo del esposo empieza a ejecutar el método deducir().
2. El hilo del esposo confirma que la cantidad a deducir es menor o igual al
total de la cuenta.
3. El hilo de la esposa empieza a ejecutar el método deducir().
4. El hilo de la esposa confirma que la cantidad a deducir es menor o igual al
total de la cuenta.
5. El hilo de la esposa ejecuta la sentencia de substraer para deducir la
cantidad, regresa verdadero y el cajero entrega el dinero.
6. El hilo del esposo ejecuta la sentencia de substraer para deducir la
cantidad, regresa verdadero y el cajero entrega el dinero.
Para tratar con este problema, el lenguaje Java provee de la palabra reservada
syncronized que impide que dos hilos ejecuten el mismo código al mismo
tiempo. Si modificamos el método deducir() de la clase cuenta de la
siguiente forma:
15. Tema 12 Hilos en Java 443
ITSON Manuel Domitsu Kono
public class Cuenta {
prívate float total;
public syncronized boolean deducir(float t) {
if(t <= total) {
total -= t;
return true;
}
return false;
}
}
Método Sincronizado
En el ejemplo anterior el método deducir() está sincronizado. Para que un
método sincronizado pueda ejecutarse, primero debe adquirir un token o candado.
Una vez que el método adquiere ese candado, ejecuta su código y al terminar
regresa el candado, sin importar la forma en que termine su ejecución, incluyendo
vía una excepción. Solo hay un candado por objeto, así que si dos hilos separados
tratan de llamar a un método sincronizado de un mismo objeto, sólo uno de ellos
puede ejecutar el método inmediatamente; el otro hilo tiene que esperar a que el
primer hilo libere el candado antes de que pueda ejecutar el método. La sintaxis
de un método sincronizado es la siguiente:
modificadorAcceso syncronized tipo nomMetodo(lista de parámetros) {
declaraciones
sentencias
}
Bloque Sincronizado
En lugar de sincronizar todo un método podemos sincronizar un bloque. Al igual
que con un método sincronizado, un bloque sincronizado debe adquirir primero un
candado para poder ejecutarse, al terminar la ejecución del bloque, regresa el
candado. Por lo tanto si hay dos hilos tratando de ejecutar el bloque, sólo uno de
los hilos lo ejecutará inmediatamente, el otro hilo deberá esperar a que el primer
hilo termine la ejecución del bloque y libere el candado para que pueda ejecutar el
bloque. La sintaxis de un bloque sincronizado es la siguiente:
syncronized(expresión) {
declaraciones
sentencias
}
Donde expresión debe ser una expresión que se evalué a un objeto, el objeto del
que se obtiene el candado.
16. 444 Hilos en Java
ITSON Manuel Domitsu Kono
Declarar un método como sincronizado es equivalente a:
modificadorAcceso tipo nomMetodo(lista de parámetros) {
syncronized(this) {
declaraciones
sentencias
}
}
Esperar y Notificar
La clase Object tiene los métodos wait() y notify(). Esos métodos permiten
que un hilo libere el candado en un momento arbitrario, y espere a que otro hilo se
lo regrese antes de continuar. Estas actividades deben ocurrir dentro de bloques
sincronizados.
Tabla 12.4 Métodos de la Clase Object Empleados con Hilos
public final void notify()
Despierta un solo hilo que está esperando por el monitor de este objeto. Si hay varios hilos
esperando por este objeto, uno de ellos es seleccionado para despertarse. La selección es
arbitraria y ocurre a la discreción de la implementación. Un hilo espera por el monitor del objeto al
llamar a alguno de sus métodos wait().
El hilo despertado no podrá proceder hasta que el hilo actual libere el candado sobre el objeto. El
hilo despertado competirá con cualquier otro hilo que este compitiendo activamente para
sincronizarse con este objeto; por ejemplo, el hilo despertado no tiene privilegios o desventajas
para ser el siguiente hilo en ponerle un candado al objeto.
Este método sólo debe llamarlo un hilo que sea el dueño del monitor del objeto. Un hilo se vuelve
el dueño del monitor del objeto en una de tres formas:
• Ejecutando una método de instancia sincronizado del objeto.
• Ejecutando el cuerpo de una sentencia sincronizada que sincroniza en el objeto.
• En los objetos de tipo Class, ejecutando un método estático de la clase.
Sólo uno de los hilos a la vez puede ser el dueño del monitor del objeto.
Lanza:
IllegalMonitorStateException – Si el hilo actual no es el dueño del monitor del
objeto.
17. Tema 12 Hilos en Java 445
ITSON Manuel Domitsu Kono
Tabla 12.4 Métodos de la Clase Object Empleados con Hilos. Cont.
public final void notifyAll()
Despierta a todos los hilos que están esperando por el monitor del objeto. Un hilo espera por el
monitor del objeto al llamar a alguno de sus métodos wait().
Los hilos despertados no podrán proceder hasta que el hilo actual libere el candado sobre el
objeto. Los hilos despertados competirán con cualquier otro hilo que este compitiendo activamente
para sincronizarse con este objeto; por ejemplo, el hilo despertado no tiene privilegios o
desventajas para ser el siguiente hilo en ponerle un candado al objeto.
Este método sólo debe llamarlo un hilo que sea el dueño del monitor del objeto.
Lanza:
IllegalMonitorStateException – Si el hilo actual no es el dueño del monitor del
objeto.
public final void wait(long timeout) throws InterruptedException
Hace que el hilo actual espere hasta que otro hilo invoque al método notify() o al método
notifyAll() de este objeto, o la cantidad de milisegundos especificada por el parámetro haya
transcurrido.
El hilo actual debe poseer el monitor de este objeto.
Este método hace que el hilo actual se coloque en el estado de espera para este objeto y luego
libere cualquier derecho de sincronización en este objeto. El hilo deja de estar disponible para el
planificador de procesos y permanece dormido hasta que alguna de estas cuatro cosas suceden:
• Algún otro hilo invoca al método notify() para este objeto y el hilo es seleccionado
arbitrariamente para ser el hilo a despertar.
• Algún otro hilo invoca al método notifyAll() para este objeto.
• Algún otro hilo interrumpe al hilo.
• El tiempo en milisegundos especificado por el parámetro ha transcurrido (más o menos).
Si timeout es cero, el hilo espera hasta ser notificado.
El hilo es removido del estado de espera para este objeto y queda disponible para el planificador
de procesos. Luego compite con los otros hilos por el derecho de sincronizarse con el objeto. Una
vez que ha ganado el control del objeto, todos sus derechos de sincronización en el objeto se
restablecen al estado que tenían en el momento en que se invoco al método wait(). El hilo luego
regresa del método wait().
Lanza:
IllegalArgumentException – Si el valor de timeout es negativo.
IllegalMonitorStateException – Si el hilo actual no es el dueño del monitor del
objeto.
InterruptedException – Si cualquier hilo ha interrumpido el corriente hilo antes o
mientras el hilo actual está esperando por una notificación. El estado de interrumpido del
hilo actual se limpia cuando se lanza la excepción.
18. 446 Hilos en Java
ITSON Manuel Domitsu Kono
Tabla 12.4 Métodos de la Clase Object Empleados con Hilos. Cont.
public final void wait(long timeout, int nanos)
throws InterruptedException
Hace que el hilo actual espere hasta que otro hilo invoque al método notify() o al método
notifyAll() de este objeto, u otro hilo interrumpa al hilo actual o la cantidad de tiempo dado
por sus parámetros haya transcurrido.
El método es similar al método wait con un solo parámetro, pero permite un control más fino sobre
la cantidad de tiempo a esperar por la notificación antes de continuar. El tiempo a esperar medido
en nanosegundos está dada por:
1000000*timeout+nanos
En todos los demás aspectos, este método es similar al método wait (long
timeout). En particular wait(0, 0) significa lo mismo que wait(0).
public final void wait() throws InterruptedException
Este método se comporta como si se llamara a wait(0).
Al ejecutar el método wait() desde un bloque sincronizado, un hilo libera el
candado y se duerme. Un hilo puede hacer eso si necesita esperar que pase algo
en otra parte de la aplicación. Más tarde cuando el evento esperado pase, el hilo
que está en ejecución llama al método notify() desde un bloque sincronizado
en el mismo objeto. Entonces el primer hilo se despierta y empieza a tratar de
adquirir el candado otra vez.
Cuando el primer hilo logra obtener de nuevo el candado, continúa desde el punto
en que se quedó. Sin embargo, el hilo que estaba esperando puede no adquirir el
candado inmediatamente (o tal vez, nunca). Depende de cuando el segundo hilo
eventualmente libere el candado, y que hilo logre atraparlo enseguida. El primer
hilo no se despertará a menos que otro hilo llame al método notify() . Hay una
versión sobrecargada de wait(), que permite especificar un tiempo de
expiración. Si otro hilo no invoca al método notify() en el tiempo especificado,
el hilo se despierta automáticamente.
Para cada llamada a notify(), Java despierta uno de los métodos dormidos en
la llamada a wait(). Si hay varios métodos esperando, Java selecciona al primer
hilo en base a primero en entrar – primero en salir.
La clase Object también tiene el método notifyAll() que permite despertar a
todos los hilos esperando. En la mayoría de los casos se desea llamar a
notifyAll() en vez de notify().
19. Tema 12 Hilos en Java 447
ITSON Manuel Domitsu Kono
Ejemplo sobre Esperar y Notificar
Considere el siguiente ejemplo. Se quiere simular el comportamiento de una cola a
la que llegan clientes a ser atendidos. Los clientes son atendidos en una o varias
estaciones. Para modelar la atención que recibe el cliente se tiene la clase Tarea:
Tarea.java
/*
* Tarea.java
*
* @author mdomitsu
*/
package cola;
import java.util.Date;
public class Tarea {
int numTarea;
Date timeStamp;
int duracion;
public Tarea(int numTarea) {
this.numTarea = numTarea;
timeStamp = new Date();
duracion = GeneradorAleatorio.getPoisson(1);
}
public int getDuracion() {
return duracion;
}
public int getNumTarea() {
return numTarea;
}
public Date getTimeStamp() {
return timeStamp;
}
@Override
public String toString() {
return "Tarea " + numTarea + ": " + duracion + ", "
+ timeStamp.toString();
}
}
El atributo duracion de la clase Tarea, modela el tiempo que el cliente tarda en
ser atendido. Para establecer ese tiempo se utiliza un generador de números
aleatorios que tiene una distribución de probabilidad de Poisson. Su código se
encuentra en la clase GeneradorAleatorio.
20. 448 Hilos en Java
ITSON Manuel Domitsu Kono
GeneradorAleatorio.java
/*
* GeneradorAleatorio.java
*
* @author mdomitsu
*/
package cola;
public class GeneradorAleatorio {
public static int getPoisson(double lambda) {
double L = Math.exp(-lambda);
double p = 1.0;
int k = 0;
do {
k++;
p *= Math.random();
} while (p > L);
return k - 1;
}
}
La clase ColaTareas representa la cola a la que llegan los clientes en espera de
ser atendidos. La cola tiene un tamaño máximo de 5. Si la cola está llena, los
clientes deben esperan a que haya espacio para entrar a la cola.
ColaTareas.java
/*
* ColaTareas.java
*
* @author mdomitsu
*/
package cola;
import java.util.ArrayList;
import java.util.List;
public class ColaTareas {
private List<Tarea> colaTareas = new ArrayList<Tarea>();
private static final int MAXQUEUE = 5;
public synchronized void ponTarea(Tarea tarea)
throws InterruptedException {
while (colaTareas.size() == MAXQUEUE) {
wait();
}
colaTareas.add(tarea);
notify();
}
public synchronized Tarea obtenTarea() throws InterruptedException {
notify();
21. Tema 12 Hilos en Java 449
ITSON Manuel Domitsu Kono
while (colaTareas.size() == 0) {
wait();
}
Tarea tarea = colaTareas.get(0);
colaTareas.remove(tarea);
return tarea;
}
public synchronized int getTamano() {
return colaTareas.size();
}
}
Para modelar el arribo de los clientes se tiene el método produceTarea() que
agrega un cliente a la cola. Para establecer ese tiempo entre arribos de los
clientes se utiliza un generador de números aleatorios que tiene una distribución
de probabilidad de Poisson. Los clientes llegan más rápido de lo que pueden ser
atendidos.
Productor.java
/*
* Productor.java
*
* @author mdomitsu
*/
package hilos;
import cola.ColaTareas;
import cola.GeneradorAleatorio;
import cola.Tarea;
public class Productor extends Thread {
private static final int MAX_TAREAS = 10;
private ColaTareas colaTareas;
public Productor(ColaTareas colaTareas) {
this.colaTareas = colaTareas;
}
@Override
public void run() {
int i = 0;
try {
while (i < MAX_TAREAS) {
produceTarea(i);
// Simula el tiempo entre llegadas
sleep(1000 * GeneradorAleatorio.getPoisson(0.5));
i++;
}
} catch (InterruptedException e) {
}
}
22. 450 Hilos en Java
ITSON Manuel Domitsu Kono
private void produceTarea(int i) throws InterruptedException {
Tarea tarea = new Tarea(i);
colaTareas.ponTarea(tarea);
System.out.println("Productor: " + tarea + ", "
+ colaTareas.getTamano());
}
}
Para modelar la atención de los clientes se tiene la clase Consumidor.
Consumidor.java
/*
* Consumidor.java
*
* @author mdomitsu
*/
package hilos;
import cola.ColaTareas;
import cola.Tarea;
public class Consumidor extends Thread {
private ColaTareas colaTareas;
public Consumidor(String nombre, ColaTareas colaTareas) {
super(nombre);
this.colaTareas = colaTareas;
}
@Override
public void run() {
try {
while (true) {
Tarea tarea = consumeTarea();
sleep(1000 * tarea.getDuracion());
}
} catch (InterruptedException e) {}
}
public Tarea consumeTarea() throws InterruptedException {
Tarea tarea;
tarea = colaTareas.obtenTarea();
System.out.println(getName() + ": " + tarea+ ", "
+ colaTareas.getTamano());
return tarea;
}
}
En la siguiente clase de prueba se simula el caso de que hay una solo estación de
atención para los clientes: