miércoles, 25 de abril de 2012

Hilos


Hilos de Java 

Concepto   de hilo:

Un hilo es una secuencia de instrucciones que está controlada por un planificador que se comporta como un flujo de control secuencial. El planificador gestiona el tiempo de ejecución del procesador y asigna de alguna manera dicho tiempo a los diferentes hilos actualmente presentes.

Normalmente los hilos de un proceso (en este contexto el proceso es lo que se suele llamar así en el ámbito de sistemas operativos) suelen tener acceso a todos los recursos disponibles al proceso, es decir, actúan sobre una memoria compartida. Los problemas y sorpresas de dicho funcionamiento veremos más.

 Concepto La programación multihilos (Threads):

 Esta definida como la que ejecuta varias tareas de forma simultanea, separadas por procesos o espacios de memoria en los cuales se ejecutan estos procesos, asignandoles un tiempo de procesador, el cual esta dado por la prioridad de estosadelante.



En Java los hilos están en el paquete
java.lang.thread
y se puede usar por ejemplo dos hilos para realizar un pequeño pingPONG:
Thread PingThread = new Thread();
PingThread.start();
Thread PongThread = new Thread();
PongThread.start();
Por defecto, un hilo nuevamente creado y lanzado aún siendo activado así no hace nada. Sin embargo, los hilos se ejecutan durante un tiempo infinito y hay que abortar el programa de forma bruta: control-C en el terminal.
Extendemos la clase y sobre-escribimos el método run()para que haga algo útil:
public class CD_PingThread extends Thread {
  public void run() {
    while(true) {
      System.out.print("ping ");
    }
  }
}
El hilo hereda todo de la clase Thread, pero sobre-escribe el método run(). Hacemos lo mismo para el otro hilo:
public class CD_PongThread extends Thread {
  public void run() {
    while(true) {
      System.out.print("PONG "); 
    } 
  }
}
Y reprogramamos el hilo principal:
CD_PingThread PingThread=new CD_PingThread();
PingThread.start();
CD_PongThread PongThread=new CD_PongThread();
PongThread.start();

Métodos de Clase

Estos son los métodos estáticos que deben llamarse de manera directa en la clase Thread.
currentThread()
Este método devuelve el objeto thread que representa al hilo de ejecución que se está ejecutando actualmente.
yield()
Este método hace que el intérprete cambie de contexto entre el hilo actual y el siguiente hilo ejecutable disponible. Es una manera de asegurar que nos hilos de menor prioridad no sufran inanición.
sleep( long )
El método sleep() provoca que el intérprete ponga al hilo en curso a dormir durante el número de milisegundos que se indiquen en el parámetro de invocación. Una vez transcurridos esos milisegundos, dicho hilo volverá a estar disponible para su ejecución. Los relojes asociados a la mayor parte de los intérpretes de Java no serán capaces de obtener precisiones mayores de 10 milisegundos, por mucho que se permita indicar hasta nanosegundos en la llamada alternativa a este método.
Métodos de Instancia
Aquí no están recogidos todos los métodos de la clase Thread, sino solamente los más interesantes, porque los demás corresponden a áreas en donde el estándar de Java no está completo, y puede que se queden obsoletos en la próxima versión del JDK, por ello, si se desea completar la información que aquí se expone se ha de recurrir a la documentación del interfaz de programación de aplicación (API) del JDK.
start()
Este método indica al intérprete de Java que cree un contexto del hilo del sistema y comience a ejecutarlo. A continuación, el método run() de este hilo será invocado en el nuevo contexto del hilo. Hay que tener precaución de no llamar al método start() más de una vez sobre un hilo determinado.
run()
El método run() constituye el cuerpo de un hilo en ejecución. Este es el único método del interfaz Runnable. Es llamado por el método start() después de que el hilo apropiado del sistema se haya inicializado. Siempre que el método run() devuelva el control, el hilo actual se detendrá.
stop()
Este método provoca que el hilo se detenga de manera inmediata. A menudo constituye una manera brusca de detener un hilo, especialmente si este método se ejecuta sobre el hilo en curso. En tal caso, la línea inmediatamente posterior a la llamada al método stop() no llega a ejecutarse jamás, pues el contexto del hilo muere antes de que stop() devuelva el control. Una forma más elegante de detener un hilo es utilizar alguna variable que ocasione que el método run() termine de manera ordenada. En realidad, nunca se debería recurrir al uso de este método.
suspend()
El método suspend() es distinto de stop(). suspend() toma el hilo y provoca que se detenga su ejecución sin destruir el hilo de sistema subyacente, ni el estado del hilo anteriormente en ejecución. Si la ejecución de un hilo se suspende, puede llamarse a resume() sobre el mismo hilo para lograr que vuelva a ejecutarse de nuevo.
resume()
El método resume() se utiliza para revivir un hilo suspendido. No hay garantías de que el hilo comience a ejecutarse inmediatamente, ya que puede haber un hilo de mayor prioridad en ejecución actualmente, pero resume() ocasiona que el hilo vuelva a ser un candidato a ser ejecutado.
setPriority( int )
El método setPriority() asigna al hilo la prioridad indicada por el valor pasado como parámetro. Hay bastantes constantes predefinidas para la prioridad, definidas en la clase Thread, tales como MIN_PRIORITY, NORM_PRIORITY y MAX_PRIORITY, que toman los valores 1, 5 y 10, respectivamente. Como guía aproximada de utilización, se puede establecer que la mayor parte de los procesos a nivel de usuario deberían tomar una prioridad en torno a NORM_PRIORITY. Las tareas en segundo plano, como una entrada/salida a red o el nuevo dibujo de la pantalla, deberían tener una prioridad cercana a MIN_PRIORITY. Con las tareas a las que se fije la máxima prioridad, en torno a MAX_PRIORITY, hay que ser especialmente cuidadosos, porque si no se hacen llamadas a sleep() o yield(), se puede provocar que el intérprete Java quede totalmente fuera de control.
getPriority()
Este método devuelve la prioridad del hilo de ejecución en curso, que es un valor comprendido entre uno y diez.
setName( String )
Este método permite identificar al hilo con un nombre menmónico. De esta manera se facilita la depuración de programas multihilo. El nombre mnemónico aparecerá en todas las líneas de trazado que se muestran cada vez que el intérprete Java imprime excepciones no capturadas.
getName()
Este método devuelve el valor actual, de tipo cadena, asignado como nombre al hilo en ejecución mediante setName().





martes, 27 de marzo de 2012

Javabeans.


CONCEPTO  DE  JAVABEAN

Un JavaBean o bean es un componente hecho en software que se puede reutilizar y que puede ser manipulado visualmente por una herramienta de programación en lenguaje Java
Por lo cual, se define un interfaz para el momento del diseño (design time) que permite a la herramienta de programación o IDE, interrogar (query) al componente y conocer las propiedades (properties) que define y los tipos de sucesos (events) que puede generar en respuesta a diversas acciones.
Aunque los beans individuales pueden variar ampliamente en funcionalidad desde los más simples a los más complejos, todos ellos comparten las siguientes características:
1.      Introspection: Permite analizar a la herramienta de programación o IDE como trabaja el bean
2.      Customization: El programador puede alterar la apariencia y la conducta del bean.
3.      Events: Informa al IDE de los sucesos que puede generar en respuesta a las acciones del usuario o del sistema, y también los sucesos que puede manejar.
4.      Properties: Permite cambiar los valores de las propiedades del bean para personalizarlo (customization).
5.      Persistence: Se puede guardar el estado de los beans que han sido personalizados por el programador, cambiando los valores de sus propiedades.
Un bean es una clase que obedece ciertas reglas:
1.      tiene que tener un constructor por defecto (sin argumentos)
2.      tiene que tener persistencia, es decir, implementar el interface Serializable.
3.      tiene que tener introspección (instrospection). 
 Los IDE reconocen ciertas pautas de diseño, nombres de las funciones miembros o métodos y definiciones de las clases, que permiten a la herramienta de programación mirar dentro del bean y conocer sus propiedades y su conducta. 

Propiedades
Una propiedad es un atributo del JavaBean que afecta a su apariencia o a su conducta. Por ejemplo, un botón puede tener las siguintes propiedades: el tamaño, la posición, el título, el color de fondo, el color del texto, si está o no habilitado, etc.
Las propiedades de un bean pueden examinarse y modificarse mediante métodos o funciones miembro, que acceden a dicha propiedad, y pueden ser de dos tipos:
 getter method: lee el valor de la propiedad
setter method: cambia el valor de la propiedad.
Un IDE que cumpla con las especificaciones de los JavaBeans sabe como analizar un bean y conocer sus propiedades. Además, crea una representación visual para cada uno de los tipos de propiedades, denominada editor de propiedades, para que el programador pueda modificarlas fácilmente en el momento del diseño.
Cuando un programador, coge un bean de la paleta de componentes y lo deposita en un panel, el IDE muestra el bean sobre el panel. Cuando seleccionamos el bean aparece una hoja de propiedades, que es una lista de las propiedades del bean, con sus editores asociados para cada una de ellas.
El IDE llama a los métodos o funciones miembro que empiezan por get, para mostrar en los editores los valores de las propiedades. Si el programador cambia el valor de una propiedad se llama a un método cuyo nombre empieza por set, para actualizar el valor de dicha propiedad y que puede o no afectar al aspecto visual del bean en el momento del diseño.
Las especificaciones JavaBeans definen un conjunto de convenciones (design patterns) que el IDE usa para inferir qué métodos corresponden a propiedades.
Cuando el IDE carga un bean, usa el mecanismo denominado reflection para examinar todos los métodos, fijándose en aquellos que empiezan por set y get. El IDE añade las propiedades que encuentra a la hoja de propiedades para que el programador personalice el bean.

Propiedades simples
Una propiedad simple representa un único valor.

Propiedades indexadas
Una propiedad indexada representa un array de valores.

Propiedades ligadas (bound)
Los objetos de una clase que tiene una propiedad ligada notifican a otros objetos (listeners) interesados, cuando el valor de dicha propiedad cambia, permitiendo a estos objetos realizar alguna acción. Cuando la propiedad cambia, se crea un objeto (event) que contiene información acerca de la propiedad (su nombre, el valor previo y el nuevo valor), y lo pasa a los otros objetos (listeners) interesados en el cambio.

Propiedades restringidas (constrained)
Una propiedad restringida es similar a una propiedad ligada salvo que los objetos (listeners) a los que se les notifica el cambio del valor de la propiedad tienen la opción de vetar (veto) cualquier cambio en el valor de dicha propiedad. (Este tipo de propiedad no se estudiará en este capítulo


                          COMO INSERTAR UN JAVABEAN

Como primer paso vedemos de tener la carpeta donde contendrán los beans.
                      Abrimos el interfaz donde lo añadiremos y abrimos la paleta.


Le damos click izquierdo en cualquier lado de la paleta.     



Nos aparecera una pantalla y le damos donde dice add from jar...
Seleccionamos la carpeta en donde se encuentran los beans.


Seleccionamos la carpeta jars.
Seleccionamos el componente que deceamos aderir

Después de seleccionarlo lo volvemos a seleccionar y le damos en siguiente.


Por ultimo le seleccionamos been y precionamos en finalizar.
El resultado es este.






domingo, 12 de febrero de 2012

Eventos

 ¡A QUÉ SE LE LLAMA  EVENTOS EN PROGRAMACION?

  •   Un evento es una acción iniciada por el usuario. 
      • Los eventos son el medio como interactúa una clase con otras o con el propio usuario, se encargan de avisar que algo ha ocurrido y de manejarlo de una forma o de otra. Cada vez que escribimos con nuestro teclado, que hacemos click en un botón o un link, que cambiamos el tamaño de un objeto, estamos generando eventos. Es por ello que, cuando programamos, debemos tener en cuenta la posibilidad (no siempre necesaria, pero lo será a medida que generemos clases cada vez más complejas), tanto de manejar eventos que sólo implican a nuestra clase como de generar nuestros propios eventos, de modo que los usuarios de nuestras clases (en principio nosotros mismos) puedan decidir cómo reaccionará su código ante ellos.
      El modo de manejar los eventos en P.O.O. se conoce como emisor/receptor, también llamado despachador/escuchador o simplemente dispatcher/listener.
      En esta dupla, la primera parte (el emisor) se encargará de lanzar el evento, mientras la segunda se encargará de recibirlo y gestionarlo como sea necesario. La primera parte será responsabilidad nuestra (los programadores de la clase) y la segunda es responsabilidad de quien utiliza la clase (en principio, también nosotros).
      Cada lenguaje tiene su propio manejador de eventos, que es el que nos permite, tanto lanzar los eventos como crear los receptores (escuchadores/listeners) que nos permitirán manejarlos. Realmente es una aplicación del patrón Observer, del que hablaremos más adelante, cuando hablemos de patrones, pero que necesariamente tocaremos en este post.
      ¿En qué consiste la emisión/recepción de eventos?
      Básicamente, de lo que se trata es de avisar (en principio sin importar si alguien escucha o no) de algún cambio en el estado de la instancia, que puede ser un click en el objeto, el final de un proceso de carga o la terminación de algún complejo proceso. Cada vez que el evento en cuestión ocurre, la instancia dirá “¡¡Hey, me ocurrió este evento!!”. Esto es lo que conocemos como broadcasting.
      Aquí es donde entra en juego el (los) receptor(es). Éste se encargará de estar atento, de escuchar (de ahí que se les llame listeners) el(los) evento(s) que ocurra en el emisor, y responderá adecuadamente.




       Tipos de eventos.
      Un evento es, en esencia, la notificación automática de que una acción ha ocurrido. Loseventos son muy utilizados en el código aplicable al mundo real por que se les utiliza pararepresentar cosas como los golpes de tecla, clics del ratón, requisiciones para refrescar lapantalla y los datos de entrantes. Los eventos se construyen sobre la base de los delegados.
      1.2.
       Generación y propagación de eventos
      También llamado burbujeo de eventos, control personalizado,
      EventBubbler 
      , demuestraun simple caso de propagación de eventos.
      EventBubbler 
      es un control compuesto quecontiene cuadros de texto, botones y un control de etiqueta.
      EventBubbler 
      burbujas de loseventos de comandos de los botones para el control de contenedor principal (sí mismo) y expone como eventos de alto nivel.
      1.3.
      Métodos de control de eventos
      Cuando una acción sobre un componente genera un evento, se espera que suceda algo,entendiendo por evento un mensaje que un objeto envía a algún otro objeto.
      1.4. 
      Creación de eventos.
      La siguiente tabla muestra los eventos más comunes.