miércoles, 14 de marzo de 2012

4.1 CONCEPTO HILO

INSTITUTO TECNOLÓGICO DE CERRO AZUL
ITCA

UNIDAD IV
PROGRAMACIÓN CONCURRENTE (MULTIHILOS)

PRESENTAN


ANAISA MARTINEZ DE LA CRUZ
EUNICE AGUIRRE CÁRDENAS
AIDE DIEGO BAUTISTA
NANCY MARLENE HERNANDEZ ROSAS
IMELDA GARCÍA HERNANDEZ


ING: MARÍA ALEJANDRA ROSAS TORO




ESPECIALIDAD:
INGENIERÍA EN SISTEMAS COMPUTACIONALES




CERRO AZUL, VERACRUZ, MÉXICO.


4.1 CONCEPTOS DE HILO


Hilo (theread) llamado también proceso ligero o subproceso, es la unidad de ejecución de un proceso y esta asociado con una secuencia de instrucciones un conjunto de registros y una pila. Cuando se crea un proceso el S.O crea su primer hilo (hilo primario) en la cual puede,a su vez,crear hilos adicionales. esto pone de manifiesto que un proceso no ejecuta,si no que es sólo el espacio de direcciones donde recide el código que es ejecutado mediante uno o más hilos.

En un S.O tradicional. Cada proceso tiene un espacio de direcciones y un único hilo  de control por ejemplo, considere que un programa que incluya la siguiente secuencia de operaciones para actualizar el saldo de una cuenta bancaria cuando se efectúa un nuevo ingreso:
Saldo=Cuenta.ObtenerSaldo ();
Saldo+=ingreso; 
Cuenta.EstablecerSaldo (saldo);
Este modelo de programación, en el que se ejecuta un solo hilo, es en el que estamos acostumbrados a trabajar habitualmente. Pero, siguiendo con el ejemplo anterior piensa en un banco real; en el varios cajeros pueden actuar simultáneamente. Ejecutar el mismo programa por cada uno de los cajeros tiene un costo elevado (recuerde los recursos que necesita). En cambio si el programa permitiera lanzar un hilo por cada petición de cada cajero para actualizar una cuenta, estaríamos en el caso múltiples hilos ejecutandose concurrente mente (multitriandi) . Esta característica ya es una realidad en los S.O modernos de hoy y como consecuencia contemplada en los lenguajes de programación actuales.

Cada hilo se ejecuta de forma estrictamente secuencial y tiene su propia pila en estados de los registros de UCP y su propio contador de un programa en cambio comparte el mismo espacio de direcciones, lo que significa compartir también las mismas variables globales, el mismo conjunto de ficheros abiertos, procesos hijos (no hilos hijos), señales, semáforos, etc.
Los hilos comparten la UCP de la misma forma que lo hacen los procesos pueden crear hilos hijos y se pueden bloquear no obstante mientras un hilo del mismo proceso, en el caso de hilos soportados por el kernel (núcleo del S.O: programas en ejecución que hacen que el sistema funcione), no sucediendo lo mismo  con los hilos soportados por una aplicación por ejemplo en Windows NT todos los hilos son soportados por el Kernel; imaginemos que alguien llaga a un cajero para depositar dinero en una cuenta y casi al mismo tiempo un segundo cliente realiza la misma operación sobre la misma cuanta en el segundo cajero quedara bloqueado asta que el registro que esta siendo actualizado por el primer cajero quede liberado.

   ESTADOS DE UN HILO

Igual  que los procesos con un solo hilo de control, los hilos pueden encontrarse en unos de los siguientes estados.
  • NUEVO.- El hilo ha sido creado pero aun no ha sido activado. Cuando se active pasará al estado preparado.  
  • PREPARADO.- El hilo está activado y le ha sido asignada la UCP.
  • EN EJECUCIÓN.- El hilo está activo y le ha sido asignada la UCP(solo hilo activos  preparados solo pueden ser ejecutados).
  • BLOQUEADO.- El hilo espera que otro elimine el bloqueo de un hilo bloqueado.
  • DORMIDO. -El  hilo está bloqueado durante una cantidad de tiempo determinada después de la cual despertará y pasará al estado preparado.
  • ESPERANDO.-El hilo está esperando que ocurra alguna cosa:una condicion,una operación de E/S o adquirir la propiedad de un objeto sincronismo.Cuando ocurra, pasará al estado preparado.
  • MUERTO.-El hilo ha finalizado (está muerto)  pero todavía no ha sido recogido por  su padre.Los hilos muertos no pueden alcanzar ningún otro estado.

Descrito en lo anterior no se muestra los estados nuevo y muerto ya que no hay estados de transición durante la vida del hilo; esto es,no se puede transitar al estado nuevo ni desde  el estado muerto.

La transición entre estados está controlada por un planificador: parte del núcleo del sistema operativo encargada que todos los hilos que esperan ejecutarse tengan su oportunidad.Si un hilo en ejecución no puede continuar pasará al estado bloqueado; o también, si puede continuar y el planificador decide que ya ha sido ejecutado el tiempo suficiente,pasará al estado preparado.Si el proceso está bloqueado pasará a preparado cuando se dé el evento por el que espera; puede estar esperando a que otro hilo elimine el bloqueo,o bien si está dormido,esperará a que pase el tiempo por el que fue enviado a este estado para ser activado; y si está preparado pasará a ejecución cuando el planificador lo decida porque los demás hilos ya han tenido su parte de tiempo de UCP.



    CUANDO SE DEBE CREAR UN HILO

    Según lo expuesto anteriormente,cada vez que se crea un proceso, el S.O crea un hilo primario.Para muchos procesos éste es el único hilo necesario.
    Sin embargo,un proceso puede crear otros hilos para ayudarse en su trabajo,utilizando la UCP al máximo posible.Por ejemplo supongamos el diseño de una aplicación procesador de texto.¿sería asertado crear un hilo separado para manipular cualquier tarea de impresión? Este permitiría al usuario continuar utilizando la aplicación mientras se está imprimiendo el documento.En cambio,¿que sucederá si los datos del documento cambian mientras se imprime? Éste es un problema que habría resolver,quizás creando un fichero temporal que contenga los datos a imprimir.
    Es evidente que los hilos son extraordinariamente útiles pero también es evidente que si no se utilizan adecuadamente pueden introducir nuevos problemas mientras tratamos de resolver otros más antiguos.Por lo tanto,es un error pensar que la mejor forma de desarrollar una aplicación es dividirla en partes que se ejecuten cada una como un hilo.


    PROGRAMAR CON HILOS

    La mayoria del soporte de java proporciona para trabajar con hilos recide  en la clase Theread del paquete  java.lang, aunque también la clase Objecto, la interfaz Runnable,la interfaz Thread.UncaughtExceptionHandler y las clases ThreadGroup y ThreadLocal del mismo paquete,así como la máquina virtual,proporcionan algún tipo de soporte. 

    CREAR UN HILO
    Los hilos de java  se pueden crear en dos formas: escribiendo una nueva clase derivada de Theread, o bien haciendo una clase existente implementa la interfaz Runnable .

    La clase Thread,que implemente la interfaz Runnable,de forma resimida,está definida asi:

    public class Thread extends Object implements Runnable

    {

    //Atributos 

    static int MAX_PRIORITY;

    //Prioridad máxima que un hilo puede tener.

    static int MIN_PRIORITY;

    //Prioridad mínima que un hilo puede tener. 

    static int NORM_PRIORITY;

    //Prioridad asignada por omisión a un hilo.

    //Constructores 

    Thread ([argumentos])

    //Métodos 

    static Theread currentThread()

    //Devuelve una referencia al hilo que actualmente esta en ejecución. 

    long getID()

    //Devuelve el identificador del hilo.

    String getName()

    //Devuelve el nombre del hilo.

    int getPriority()

    //Devuelve la prioridad del hilo. 

    void interrupt()

    //Envía este hilo al estado de preparado.

    boolean isAlive()

    //Verifica sí este hilo está vivo (no ha terminado).

    boolean isDaemon()

    //Verifica sí este hilo es un demonio. Se da este nombre  a

    //un hilo se ejecuta en segundo plano, realizando una 

    //operación específica en tiempos predefinidos, o bien en

    //respuestas a ciertos eventos.

    boolean is Interrupted()

    //Verifica si este hilo ha sido interrumpido.

    void join([milisegundos[. nanosegundos]])

    //Espera indefinidamente o el tiempo especificado,a que este

    //hilo termine (a que muera).

    void run()

    //Contiene el código que es ejecutará cuando el hilo pase

    //al estado de ejecución.Por omisión no hace nada.

    void setDaemon(boolean on)

    //Define este hilo como un demonio o como un hilo de usuario.

    void setName(String nombre)

    //Cambia el nombre de este hilo.

    void setPriority(int nuevaPrioridad)

    //Cambia la prioridad de este hilo.Por omisión es normal

    //(NORM_PRIORITY).

    static void sleep(long milisegundos[,int nanosegundos])

    //Envía este hilo a dormir  por el tiempo especificado.

    void start()

    //Inicia la ejecución de este hilo:la máquina virtual de Java

    //invoca al método run de este hilo.

    static void yield()

    //Detiene temporalmente la ejecución de este hilo para

    //permitir la ejecución de otros.

    //Métodos heredados de la clase Object:notify,notifyAll y wait void notify()

    //Despierta un hilo de los que están esperando por el

    //monitor de este objeto.

    void notifyAll()

    //Despierta todos los hilos que están esperando por el

    //monitor de este objeto.

    void wait ([milisegundos[,nanosegundos]])

    //Envía este hilo al estado de espera hasta que otro hilo

    //invoque al método notify o notifyAll,o hasta que transcurra

    //el tiempo especificado.

    }



    Una clase que implemente la interfaz Runnable tiene que sobreescribir el método run aportado por está,de ahí que Thread proporcione este método aunque no haga nada.El método run contendrá el código que debe ejecutar el hilo.

    Los métodos stop,suspend,resume,destroy y countStackFrames incluidos en versiones anteriores han sido desaprobados porque son intrínsecamente inseguros.

    BIBLIOGRAFIA
    java 2 curso de programación
     3 edición actualizada
    por el autor. Francisco Javier Ceballos  





    jueves, 8 de marzo de 2012

    4.3 CREACIÓN Y CONTROL DE HILOS

    INSTITUTO TECNOLÓGICO DE CERRO AZUL



    PRESENTAN:


    Ø  Flores Ordóñez Lei Lani
     Ø  González Hernández Carlos Arturo
    Ø  Hernández Gabriel Juan Carlos
    Ø Rodríguez Jalife Yael   
    Ø  Santiago de la Cruz Martin Fco.


    MATERIA:

    Tópicos Avanzados de Programación


    PROFESOR:

    Lic. Ma. Alejandra Rosas Toro



    miércoles, 7 de marzo de 2012

    3.3 USO DE LIBRERÍAS PROPORCIONADAS POR EL LENGUAJE

     INSTITUTO TECNOLÓGICO 
     DE CERRO AZUL

     MATERIA:
              TÓPICOS AVANZADOS  DE PROGRAMACIÓN

        CATEDRÁTICO:
             M.en C. MARÍA ALEJANDRA ROSAS TORO

           TRABAJO: 
       EXPOSICIÓN DEL TEMA
           3.3 USO DE LIBRERÍAS PROPORCIONADAS POR EL LENGUAJE

          INTEGRANTES:
       GALLARDO GASPAR SAUL
           REYES VITE ANA KAREN
          ANGELES PEREZ GREGORIO
         GONZALES TERAN EDITH MONSERRAT

               ESPECIALIDAD:
                ING.SISTEMAS COMPUTACIONALES




                            3.3 USO DE LIBRERÍAS PROPORCIONADAS POR EL LENGUAJE

    Java es un lenguaje de programación desarrollado para una multitud de plataformas y procesadores.
    Consideremos los dos tipos de aplicaciones gráficas más comunes.
    Modelos de Frames y Applets, se pueden construir usando cualquiera de las dos galerías de componentes visuales, son:
    1. JAVA AWT: Es la librería visual más antigua de java usando esta librería, se podrán construir los tres tipos de programas mas comunes como son FRAME, WINDOW  y APPLET.
    2. JAVA  SWING: Es la librería de componentes visuales más nueva que proporciona java, usando esta librería se podrán construir los tres tipos de programas o aplicaciones que son JFRAME,WINDOW Y JAPPLET.

     Un applet es un programa en java que se mandan a una máquina o PC remota para que los ejecuten o lo corra, cuando este applet de llegada a las máquinas remotas vía browser, dicho browser es quien activa la máquina virtual de java que da la orden de compilación y ejecución, es decir java programa.applet.


    Entonces es importante que la máquina virtual de java, que se encuentra en la PC remota,tenga capacidad de incluir  todas las librerías de java, como la de match, la de AWT, la de lang.etc.

    Existen diferentes librerías en java, entre las cuales se encuentra.


    • Java. lang


    Colección de tipo básico siempre importados a cualquier unidad de compilación. Aquí están las declaraciones de  objetos, clases, wrappers.


    Interfaces Clases.
    Cloneables Boolean
    Comparable Byte
    Runnable Character
    ClassLoader
    Compiler
    Double
    Float
    InheritableThreadLocal
    Interger
    Long
    Math
    Number
    Object
    System
    Thread
    Void String, etc..


    • Java.io
    Archivos de stream y acceso aleatorio. Librería estándar de entrada y salida.
    Interfaces Clases
    DataInput BufferedInputStream
    DataOutput BufferedOutputStream
    Externalizable BufferedReader
    Filefilter Bufferedwrite
    FilenameFilter ByteArrayInputStream
    OdjectInput ByteArrayOutputStream
    Serializable DataOutputStream
    File
    InputStream reader
    Writer,etc..


    • Java.net
    Librería que apoya interfaces con telnet y URL.


    Interfaces Clases
    ContentHandlerFactory Authenticator
    DatagramSocketImplFactory ContentHandler
    FileNameMap DatagramPacket
    SocketOptions DatagramSocketImpl
    URLStreamHanlerFactory HttpURKConnection URL, etc..


    • Java.util
    Clase como de diccionarios, tabla de hash, stack, técnica  de codificación  hora, fecha, etc.


    Interfaces Clases
    Collection AdstractCollection
    Comparator AdstracList
    Enumeration AdstrectMap
    EventListener AdstrectSecquentialList
    Interator AdstractSet
    List ArreyList
    Observer Collection
    SortedSet EventObject
    Random Stack
    Timer
    Vector
    Date,etc.


    • Java.Awt
    Abstract Windowing Toolkit que proporciona una capa abstracta que permita llevar una aplicación en java de un sistema de ventanas a otro. Contiene clases para componentes básicos de la interfaz, tales como eventos, colores, tipos de letra, botones, campos de texto.


    Estructura del awt.
    La estructura de la versión actual del AWT en la plataforma Java 2 se puede resumir en los puntos siguientes:


    • Los contenedores contienen componentes, que son los controládores  básicos.
    • No se usan posiciones fijas de los componentes, si no estan situados a traves de una disposición controlado (layouts)
    • El común denominador de mas bajo nivel se acerca al teclado, ratón y manejo de eventos.
    • Alto nivel de abstracción respecto al entorno de ventanas en que se ejecute la aplicación (no hay áreas clientes, ni llamadas a X ).
    • La arquitectura de la aplicación es dependiente del entorno de ventanas, en vez de tener un tamaño fijo.
    • Carece de un formato de recursos. No se puede separar el código de lo que es propiamente interfaz. No hay ningún diseñador de interfaz toda vía.
    Interfaces Clases
    ActiveEvent AlphaComposite
    Adjustable AWTEvent


    • Java.applet
    El paquete java.applet permite la creación de applets  atraves de la clase Applet, proporciona interfaces para conectar un applet a un documento web y para audición de audio.
    Interfaces Clases
    AppletContext Applet
    AppletStub 
    AudiClip


    • Java.math
    Proporciona cálculos en entero grande y real grande.
    Clases
    Bigdecimal
    Biginteger
    Además de la clase Math.


    Esta es la clase que representa la librería matemática de Java. Las funciones que contiene son las de todos  los lenguajes, parece que se han metido en una clase solamente a propósito de agrupación, por eso se encapsulan en Math, y lo mismo sucede con las demás clases que corresponde a objetos que tiene un tipo equivalente(carácter, Float, etc.)
    La clase Math es public para que se pueda llamar desde cualquier sitio y static para que no haya que iniciarla.


    • Java.rmi
    Este paquete hace posible que un objeto se ejecute en una maquina virtual Java invoque métodos de otro objeto que se ejecuta en la máquina virtual distinta; dicha máquina virtual pueden encontrarse en ordenadores diferentes conectados a través de una red TCP/IP.


    Interfaces Clases
    Rmote MarshalledObject
    Naming
    RMISecurityManager


    • Java.text
    Contiene clase que permiten dar formato especializado a fechas, números y mensajes.
    Interfaces Clases
    AttributedChacterIterator Annotation
    CharacterIterator AttibutedCharacterIterator
    ChoceFormat
    DateFormat
    Format
    MessageFormat
    NumberFormat
    ParsePosition


    • Java.sound.midi
    Paquete con clase e interfaces que permitan la captura, procesamiento y reproducción de música MIDI.
    Interfaces Clases
    ControllerEventListener Instrument
    MataEventListener MeteMessage
    MidiChannel MidiDevice.info
    MidiDevice MidiEvent
    Receiver MidiFileFormat
    Sequecer Midemessage




    • JAVA .SQL
    Junto con el paquete javax.sql, incluido en java 2 SDK Edición para la empresa, forma parte del API de java 2.0 (conexión Java a Base de Datos), y permite la conexión de base de datos, el envió de sentencias SQL y la interpretación de los resultados de las consultas.


    Intefaces Clases
    Array Date
    Blob DriverManager
    CallabeStatement DriverPropertyInfo
    Clob SQLPermission
    Connecction Timer
    DatabaseMetaDate Timestamp
    Driver Type
    Ref
    SQLData
    SQLInput
    SQLOutput
    Struct




    • JAVA.SWING
    Paquete que mejora e AWT, proporcionando un conjunto de componentes que se ejecutan de manera uniforme en todas las plataformas.
    Interfaces Clases
    Action AbstractAction
    ComboBoxEditor ActonMap
    Icon Box.Filler
    ListModel CellRendererPane
    MenuElement DebugGraphics
    WindowsConstants DefaulListSelectionModel
    JApplet
    Jbutton
    JCheckBox
    JFrame JMenu
    JLabel
    JPanel
    JTextField
    JTree
    JWindows
    Temer
    UIManager, etc..






    EJEMPLOS DONDE PODEMOS NOTAR EL USO DE LAS LIBRERÍAS.
    import java.awt.*;
    import java.awt.event.*;
    import javax.swing.*;

    public class AparienciaVisual extends JFrame {
       private final String cadenas[] = { "Metal", "Motif", "Windows" };
       private UIManager.LookAndFeelInfo apariencias[];
       private JRadioButton opción[];
       private ButtonGroup grupo;
       private JButton botón;
       private JLabel etiqueta;
       private JComboBox cuadroCombinado;
    String s1=""; 
       public AparienciaVisual()
       {
          super( "apariencia visual" );
          Container contenedor = getContentPane();
          // establecer panel para región NORTH de esquema 
    BorderLayout
          JPanel panelNorte = new JPanel();
          panelNorte.setLayout( new GridLayout( 3, 1, 0, 5 ) );
          // establecer etiqueta para panel NORTH
          etiqueta = new JLabel( "Ésta es la apariencia visual Metal seleccionada",


    // CREA UN ARCHIVO DE ACCESO ALEATORIO, ESCRIBIENDO 100 REGISTROS VACÍOS EN EL DISCO.

    import java.io.*;
    import javax.swing.*;

    public class CrearArchivoAleatorio {   
        private static final int NUMERO_REGISTROS = 100;
       // permitir al usuario seleccionar el archivo a abrir
       private void crearArchivo()
       {
          // mostrar cuadro de diálogo para que el usuario pueda seleccionar el archivo
          JFileChooser selectorArchivo = new JFileChooser();
          selectorArchivo.setFileSelectionMode( JFileChooser.FILES_ONLY );
          int resultado = selectorArchivo.showSaveDialog( null );  
          // si el usuario hizo clic en el botón Cancelar del cuadro de diálogo, regresar
          if ( resultado == JFileChooser.CANCEL_OPTION )
             return;
          // obtener el archivo seleccionado
          File nombreArchivo = selectorArchivo.getSelectedFile();
          // mostrar error si el nombre del archivo es inválido
          if ( nombreArchivo == null || nombreArchivo.getName().equals( "" ) )
           



    Referencias:

    fundamentos de programación en java 2
    Autor:
    Schild, herbert
    Mc Graw Hill


    Java 2 manual de usuarios y tutorial    4 Edición 
    Autor:
    Agustín Froufe Quintas 

    4.2 Comparacion de un Programa de Flujo Unico Contra uno de Flujo Multiple

    Programas De Flujo Unico
    Un programa de flujo único, tarea única o mono -hilo (single-thread) utiliza un único flujo de control (thread) para controlar su ejecución. Muchos programas no necesitan la potencia o utilidad de multiples tareas. sin necesidad para especificar explicitamente que se quiere un único flujo de control, muchos de los applets y aplicaciones son de flujo único.

    Por ejemplo, en la aplicación estádar de saludo para aprender cualquier lenguaje de programación:
    public class HolaMundo{
    public static void main (string args[]){
    System.out.println( " Hola Mundo " );
    }
    }

    Aqui, Cuando se llama al main(), la aplicación imprime el mensaje y termina. Esto ocurre dentro de una única tarea (thread).
    Debido aque la mayor parte de los entornos operativos no solían ofrecer un soporte razonable para múltiples tarea, los leguajes de programación tradicionales, tales como c++, no incorporaron mecanimos para describir de manera elegante situaciones de este tipo. La sincronización entre las múltiples partes de un programa se lleba a cabo a medida de un bucle de sucecion único. Estos entornos son de tipo síncrono, gestionados por sucesos. Entornos tales como el de MacOs de Apple,Windows de Microsft y X11/Motif fueron diseñados al entorno del bucle del suceso.

    PROGRAMAS DE FLUJO MÚLTIPLE

    En la aplicación de Saludo, no se ve la tarea que está ejecutando el programa. Sin embargo, java posibilita la creación de tareas explícitamente. La utilización de las tareas (threads) en java permite una enorme flexibilidad a los programadores a la hora de plantearse el desarrollo de aplicaciones. La simplicidad para crear, configurar y ejecutar tareas permite que se puedan implementar muy poderosas y portables aplicaciones/applets que no se pueden crear con lenguajes de tercera generación. En un lenguaje orientado a Internet como es Java, esta herramienta es vital.

    Si el lector a utilizado un navegador con soporte en Java, ya habrá visto el uso de múltiples tareas en Java. Habrá observado que dos applets se pueden ejecutar al mismo tiempo, o bien que puede desplazar la página del navegador mientras el applet continúa ejecutándose. Esto no significa que el applet utilice múltiples tareas, sino que el navegador es multitareas, multihilo, multihilvanado o multithreaded.

    Los navegadores utilizan diferentes tareas ejecutándose en paralelo para realizar varias tareas,"aparentemente" de forma concurrente. Por ejemplo, en muchas páginas Web se puede desplazar la página e ir leyendo el texto antes de que todas la imágenes estén presentes en la pantalla. En este caso, el navegador está descargando las imagenes en una tarea y soportando el desplazamiento de la página en otra tarea diferente.

    Las aplicaciones (y applets) multitarea utiliza muchos contextos de ejecución para cumplir su trabajo. Se aprovecha del hecho de que muchas tareas contienen subtareas distintas e independientes. Se puede utilizar un hilo de ejecución para cada subtarea.

    Mientras que los programas de flujo único pueden realizar su tarea ejecutando las subtareas secuencialmente, un programa multitarea permite que cada tarea comience y termine tan pronto como sea posible. Este comportamiento presenta una mejor respuesta a la entrada en tiempo real.

    Acontinuación, se va a modificar el programa de saludo creando tres tareas individuales, que imprimen cada una de ellas su propio mensaje de saludo,

    MultiHola.java:

    import java.awt.*;
    import java.awt.event.*;
    import java.io.*;

    class TestTh extends Thread {
    private String nombre;
    private int retardo;

    // Constructor para almacenar nuestro nombre y el retraso

    public TestTh( String s,int d) {
    nombre = s;
    retardo = d;
    }
    //El método run() es similar al main(), pero para threads. Cuando
    // run() termina el thread muere
    public void run( ) {
    // Retrasamos la ejecución el tiempo especificado
    try {
    sleep( retardo );
    } catch( InterruptedException e ) {
    ;
    }

    // Ahora imprimimos el nombre
    System.out.println(" Hola Mundo! " +nombre+ " " +retardo );
    }
    }

    public class MultiHola{
    public static void main (String args[ ] ) {
    TestTh t1,t2,t3;
    //Creamos los threads
    t1 = new TestTh(" Thread 1", (int)(Math.random()*2000) );
    t2 = new TestTh("Thread 2",(int)(Math.random()*2000) );
    t3 = new TestTh("Thread 3",(int)(Math.random()*2000));
    //Arrancamos las threads
    t1.start();
    t2.start();
    t3.start();
    }
    }


    FUENTE DE INFORMACION

    Java 2 Manual de Usuario y Tutorial 5ª Edición

    Autor: Agustin Froufe Quintas

    Editorial: Alfaomega

    pag: 202 , 203 y 204



    INTEGRANTES

    GARCEZ CRUZ GONZALO
    BUSTOS HERNANDEZ MARIA TERESA
    BUENDIA HERRERA CRISTIAN
    MARTINEZ HERNANDEZ MIGUEL ANGEL
    FRANCISCO ANTONIO ALBERTO


    3.5 CREACIÓN Y USO DE PAQUETES/LIBRERIAS DEFINIDAS POR EL USUARIO

    Los paquetes son grupos de clases relacionadas; ayudan a organizar su código y proporcionan otra capa encapsulamiento.
    En programación, los paquetes, con frecuencia son útiles para agrupar las piezas relacionadas de un programa.
    Un paquete sirve para dos propósitos: primero, suministra un mecanismo por el cual piezas relacionadas de un programa pueden ser organizadas como una unidad. Se debe tener acceso a las clases definidas dentro de un paquete a través de su nombre de paquete. Así, un paquete proporciona la manera de nombrar una colección de clases.
    Segundo, un paquete participa en los mecanismos de control de acceso en java. Las clases definidas dentro de un paquete pueden hacerse privadas a ese paquete y no accesibles por código fuera del paquete. De este modo, el paquete suministra un medio por el cual las clases pueden ser encapsuladas.

    DEFINIR UN PAQUETE:

    Todas las clases en Java pertenecen a algún paquete. Como se mencionó anteriormente, cuando no se especifica la declaración  package se usa el paquete predeterminado (o global). Además, el paquete predeterminado no tiene nombre, lo que lo hace transparente. 
    Aunque el paquete predeterminado es válido para programas de prueba cortos, es inadecuado para aplicaciones reales.

    Para crear un paquete, coloque un comando package en la parte superior del archivo fuente de java.
    Las clases declaradas dentro de ese archivo pertenecerán al paquete específicado. Puesto que un paquete define un espacio de nombre, los nombres de las clases que coloque dentro del archivo se convierten en parte de ese espacio del nombre del paquete.
        
    La siguiente es la forma general de la declaración package:
            package pkg;
    Aquí, pkg es el nombre del paquete. Por ejemplo, el siguiente enunciado crea un paquete de nombre Project1.

            package Project1;

    Java usa el sistema de archivo para manejar los paquetes con cada paquete almacenado en su propio directorio. Por ejemplo, los archivos .class para las clases que usted declare sean partes de Project1 debe guardarse en un directorio llamado Project1.

    Puede crear una jerarquía de paquetes. Para hacerlo, simplemente, separe cada nombre de paquete del inmediatamente anterior, por medio de un punto. A continuación, la forma general de una declaración de paquete multinivel:

         package pack1.pack2.pack3....packN;

    Por supuesto, debe crear directorios que soporten la jerarquía del paquete que crea. Por ejemplo:

        paquete x.y.z;           

     Debe almacenarse en  ...../X/Y/Z, donde ... especifica la ruta a los directorios específicos.

    ENCONTRAR PAQUETES Y CLASSPATH:

    Como se explicó, los paquetes son reflejados por los directorios. Esto provoca una pregunta importante: ¿Cómo sabe el sistema en tiempo de ejecución  de java dónde buscar los paquetes que usted creó? La respuesta tiene dos partes. Primero, por defecto: el sistema de tiempo de ejecución de java busca en el directorio un curso como su punto de partida. Así, si sus archivos de clase están en el directorio actual, o en un subdirectorio del directorio actual, ellos se encontrarán. Segundo, puede especificar una ruta o rutas de directorios colocando la variable ambiental CLASSPATH.   
        Por ejemplo considere la siguiente especificación de paquete:

        package MyPack;

    Para que un programa encuentre MyPack, una de estas opciones debe ser cierta: el programa es ejecutado desde un directorio inmediatamente anterior a MyPack, o CLASSPATH debe crearse para incluir la ruta a MyPack. La primera alternativa es la mas fácil (y no requiere un cambio a CLASSPATH), pero la segunda le permite a su programa encontrar MyPack sin importar en cual directorio esta el programa.

    UN EJEMPLO BREVE DE UN PAQUETE:

    Teniendo en cuenta la discusión anterior pruebe este ejemplo breve de paquete. Éste crea una base de datos simple de libro que esta contenido dentro del paquete BookPack.

    //Demostración del uso de un paquete
    package BookPack;
    class Book{
           private String title;
           private String author;
           private int pubDate;
    Book (String t, String a, int d){
             title= t;
             author= a;
             pubDate= d;
    }
    void show( ) {
           System.out.println (title);
           System.out.println (author);
          System.out.println (pubDate);
          System.out.println ( );
        }
    }

    class BookDemo {
     public static void main ( String args[ ] ){
          Book book [ ] = new Book [5];
          book[0] = new Book ("java Beginner´s Guide", "Schildt", 2001);
          book[1] = new Book ("java 2 programer´s Reference", "Schildt", 2000);
           book[2] = new Book ("HTML Programer´s Reference", "Powell and Whitworth", 1998);
          book[3] = new Book ("Red Storm Rising", "Clancy", 1986);
          book[4] = new Book ("On the Road", "Kerouac", 1955);
    for (int i=0; i < book.length; i++)  book[ i ].show( );
         }
    }

    Llame este archivo BookDemo.java y colóquelo en un directorio de nombre BookPack.
    Luego, compile el programa. Asegúrese de que el archivo resultante .class esté también en el directorio BookPack. Luego trate de ejecutar la clase, usando la siguiente linea de comando:

       java BookPack. BookDemo

    Recuerde, necesitará estar en el directorio anterior de BookPack cuando ejecute este comando o hacer que su variable ambiental CLASSPATH, este configurada apropiadamente.
    Como se dijo, BookDemo y Book ahora son parte del paquete BookPack. Esto quiere decir que BookDemo no puede ser ejecutado por sí mismo. Es decir, usted no puede usar esta línea de comando.

       java BookDemo

    En cambio, BookDemo debe calificar con su nombre de paquete.

    PAQUETES Y ACCESO A MIEMBROS

    La visibilidad de un elemento está determinada por su especificación de accesos, private, public. protected o por defecto, y el paquete en el que éste resida.De este modo, la visibilidad de un elemento está determinada por su visibilidad dentro de la clase y su visibilidad dentro del paquete.
    Si un miembro de una clase no tiene especificador de acceso explícito, entonces éste sería visible desde dentro de su paquete pero no por fuera de él. Por esto debe usar como la especificación de acceso por defecto para los elementos que quiera mantener como privados en un paquete, pero |público| dentro de ese paquete.
    Los miembros declarados public explícitamente son visibles en todas partes, incluidas en clases y paquetes diferentes. No hay restricción en su uso o acceso.

    La siguiente tabla resume los variados niveles de acceso a miembros.




    Un miembro private es accesible sólo para otro miembro de su clase y no es afectado por su afiliación a un paquete.
    Un miembro especificado como protected es accesible dentro de su paquete y a todas las subclases. incluidos. subclases en otros paquetes.
    Una clase tiene sólo dos posibles niveles de acceso : por defecto y público. Cuando una clase se declare como prublic, ésta es accesible por cualquier otro código. Si una clase tiene acceso por defecto, puede tener acceso a ella sólo por otro código dentro de su mismo paquete. También, una clse que se declare public debe residir en un archivo del mismo nombre.


    IMPORTAR PAQUETES:

     Cuando use una clase de otro paquete, puede calificar completamente el nombre de la clase cuete.on el nombre de su paquete. Sin embargo, tal aproximación puede fácilmente llegar a ser aburrida y complicada, si las clases que está calificando son profundamente anidadas en la jerarquía del paquete.
    Usando import puede traer uno o más miembros de un paquete a la vista. Esto le permite usar directamente aquellos miembros, sin hacer explícita las calificaciones del paquete.
    A continuación, la forma general de la declaración import:

        import pkg.nombre de clase; 

    Donde pkg es el nombre del paquete, que puede incluir su ruta (path) completa y nombre de clase  el de la clase importada. Si desea importar todo el contenido de un paquete, use un asterisco (*) para el nombre de clase. A continuación, ejemplos de las dos formas:

          import MyPack.MyClass
          import MyPack.*;           

    En el primer caso, la clase MyClass es importada de MyPack. En el segundo,todas las clases en MyPack son importadas. En un archivo fuente de java, las declaraciones import ocurren en seguida de la declaración package (si existe) y antes de cualquier definición de clase.
        Usted puede usar import para traer el paquete BookPack a la vista, de modo que la clase Book pueda usarse sin calificación. Para hacer esto, sólo adicione la declaración import sobre cualquier archivo que use Book.

        import BookPack,*;

    Por ejemplo, a continuación está la clase UseBook recodificada para usar import


    //muestra la senctencia import
    package BookPack;
    import BookPack;

    //uso del book desde BookPack
    class UseBook {
      public static void main ( String args []) {
     
      Book book [] =new Book [5];
      book[0] = new Book ("Java Beginners Guide", "Schildt", 2001);
      book[1] = new Book ("Java 2 programmer Reference", "Schildt", 2000);
      book[2] = new Book ("HTML Programmer Reference", "Pawell and Whitworth", 1998);
      book[3] = new Book ("Red Storm Rising ", "Clancy", 1986);
             book[4] = new Book ("On the Road", "Kerouac", 1955);
               for (int i=0; i < book.length; i++) book[i].show();        
      }
    }

    LA LIBRERIA DE  CLASE JAVA ESTA CONTENIDA EN PAQUETES:

    Esta libreria de clase con frecuencia se refiere a la Interfaz de Programación de Aplicaciones de java (Java API, Application Programming Interface). La Java API se almacena en paquetes. En la parte superior de la jerarquía del paquete está java
    Descendiendo desde java hay varios subpaquetes, incluidos estos:
       
    java.lang:  contiene un gran número de clases de propósito general
    java.io:     contiene las clases de E/S
    java.net:   contiene aquellas clases que soportan redes
    java.applet: contiene clases para crear applets
    java.awt:     contiene clases que soportan las herramientas abstractas para trabajar con ventanas de java

    El paquete java.lang es único porque es importado automáticamente dentro de cada programa java.  



    BIBLIOGRAFIA:
    Fundamentos de programacion en Java2
    Herbert Schildt



    INTEGRANTES DEL EQUIPO:
    Hernandez Jardines Viviana Anahi
    Espinoza Cruz Luis Enrique
    Carrasco Reyes Erwin Jovany
    Cruz Hernandez Luis Fernando
    Alvarado Gonzalez Cesar Alejandro







    martes, 6 de marzo de 2012

    4.4 SINCRONIZACIÓN DE HILOS

    4.4 SINCRONIZACION DE HILOS
         Cuando se están utilizando hilos múltiples,algunas veces es necesario coordinar las actividades de dos o más. El proceso por el cual se logra esto se llama sincronización. La razón más común para la sincronización es cuando dos o mas hilos necesitan acceso a un recurso compartido que  sólo puede ser utilizado por un hilo a la vez. Otra razón para la sincronización es cuando un hilo está esperando un evento causado por otro hilo. En este caso, debe de haber algún medio por el cual el primer hilo se mantenga en estado suspendido hasta que el evento ocurra.
         La sincronización esta soportada por la palabra clave synchronized y por unos cuantos métodos bien definidos que tienen todos los objetos.

    USO DE MÉTODOS SYNCHRONIZED
         Cuando se llama al método Synchronized , el hilo que llama ingresa al monitor de objeto, que entonces bloquea el objeto. Mientras esta bloqueado ningún otro hilo puede ingresar al método, ni ingresar algún otro método sincronizado definido por el objeto. Cuando el hilo retorna del método, el monitor desbloquea el objeto permitiendo que sea usado por el próximo hilo.

    Los puntos clave de un método sincronizado son:
    • Un método sincronizado se crea precediendo su declaración con synchronized.
    • Para cualquier objeto dado,una vez un método sincronizado ha sido llamado se bloquea el objeto, y los métodos no sincronizados dentro del mismo objeto pueden ser utilizados por otros hilos en ejecución.
    • Otros hilos que traten de llamar un objeto sincronizado en uso ingresaría en un estado de espera, hasta que el objeto se desbloquea.
    • Cuando un hilo sale del método sincronizado, el objeto se desbloquea.
    DECLARACIÓN SYNCHRONIZED
        La creación del método Synchronized dentro de las clases creadas por nosotros mismos es fácil y eficiente sin embargo no trabaja en todos los casos. Por ejemplo, podemos querer sincronizar el acceso a algún método que no este modificado por Synchronized ; esto ocurre cuando queremos utilizar una clase que no fue creada por nosotros sino por un tercero, y no tenemos acceso al código fuente.
         La solución para este problema es poner llamadas a los métodos definidos por esa clase dentro de un bloque Synchronized. La forma general de un bloque  Synchronized es:
    synchronized  (objeto){
                                       //declaraciones para ser sincronizadas
                                                                }

         Aquí objeto hace referencia al objeto que va a ser sincronizado. Un objeto sincronizado asegura que una llamada a un método, ocurra solo después de que el hilo que llama ha ingresado al monitor del objeto.

    EJEMPLO:
    /**
    uso de synchronized en el control de accesos
     */
    class SumArray {
              private int sum;

              synchronized int SumArray(int nums[]){
               sum=0; //inicializa sum

               for (int i=0;i<nums.length;i++){
                   sum= nums[i];
                    System.out.println ("Ejecucion total para" + Thread.currentThread().getName() + " es " + sum);

              try{
                   Thread.sleep(10); //permite el suicheo de tareas
              }
             catch (InterruptedException exc){
                      System.out.println ("Hilo principal interrumpido ");
               }
            }
         return sum;
      }    
    }
    class MyThread implements Runnable{
                     Thread thrd;
                     static  SumArray sa=new SumArray();
                     int a[];
                     int answer;

                    / /contruye un nuevo hilo
                  MyThread(String name,int nums[]){
                           thrd= new Thread (this,name);
                           thrd.start(); //arranca el hilo
                            a= nums;
                  }

                 //inicia la ejecucion del nuevo hilo
                public void run(){
                           int sum;
                           System.out.println ("Suma para " + thrd.getName() + " es " + answer);
                           System.out.println (thrd.getName() + "terminando");
              }

    }
    class Sync{
              public static void main (String[] args) {
              int a[]={1,2,3,4,5};

              MyThread mt1= new MyThread ("Hijo #1",a);
              MyThread mt2= new MyThread ("Hijo #2",a);
             }
    }


        El programa anterior crea 3 clases. La primera es SumArray que contiene el método SumArray (), que suma un arreglo entero. La segunda clase es MyThread, que utiliza un objeto de tipo SumArray para obtener la suma de un arreglo entero. Finalmente, la clase Sync crea dos hilos, y permite que ellos calculen la suma de un arreglo entero.


        Dentro de sumArray (), se llama sleep() para permitir que ocurra un cambio de tarea, pero de hecho no es posible. Porque sumArray () está sincronizada. Solamente un hilo a la vez puede utilizarla. De modo que cuando el segundo hilo hijo comience su ejecución, no ingresa sumArray() hasta después que el primer hilo hijo esté terminado. Esto asegura que se produzca el resultado correcto. 


    COMUNICACIÓN DE HILOS UTILIZANDO NOTIFY (), WAIT ()                                      Y NOTIFY ALL ()
         Los métodos wait (), notify () y notify all () son parte de todos los objetos porque están implementados por la clase Object. Estos métodos sólo pueden ser llamados desde el interior de un método Synchronized. A continuación se presenta como se utilizan. Cuando un hilo está temporalmente bloqueado para ejecución, llama a wait (). Esto hace que el hilo vaya a dormir y que el monitor para ese objeto se libere, permitiendo que otro hilo utilice el objeto. Luego en otro punto, el hilo dormido despierta cuando algún otro hilo ingresa al monitor, y llama a notify () o a notify All (). Un llamado a notify () reanuda el hilo. Una llamada a notify All () reanuda todos los hilos de más alta prioridad gana el acceso al objeto. 
        
         A continuación, se muestran varias formas de wait () definidas por Object:
    • final void wait() throws InterruptedException
    • final void waitlong milísegundos ) throws InterruptedException
    • final void wait ( long milisegundos, int nanosegundos ) throwsInterrupted-Exception      

       La primera forma espera hasta que sea notificada. La segunda forma espera hasta que sea notificada o hasta que expire el período de milísegundos. La tercera forma le permite a usted especificar el período a aguardar en términos de nanosegundos.
        A continuación, se muestran las formas generales de notify () y notify All ():
    • final void notify ()
    • final void notifyAll ()
    EJEMPLO:
        Para comprender la necesidad y aplicación de wait() y notify (), crearemos un programa que simule el tic-tac de un reloj, mostrando las palabras "tic" y "tac" en la pantalla. Para realizar esto, crearemos una clase llamada TickTock que contiene dos métodos: tick() y tock()
       Paja ejecutar el reloj se crean dos hilos, uno que llama a tick () y otro, a tock (). El objetivo es hacer que los dos hilos se ejecute de modo que el resultado del programa presentes un "tic-tac" constante.

    /* uso de wait () y notify () para crear un reloj de tarjeta. */
    class TickTock {
          synchronized void tick ( boolean running ) {
              if ( !running ) { //para el reloj
                    notify ( ); // notifica una espera para el hilo
              return:
             }  
              System.out.println ( "Tic ");
              notify ( ); // permite la ejecución del tock ()
              try {
                    wait ( ); // espera que tock ( ) se complete
              }
              catch ( InterruptedException exc ) {
                    System.out.println ( "del Hilo interrumpido  ");
              }
          }
         synchronized void tock ( boolean running ) {
                   if (!running) { //para el reloj
                         notify  ( ); // notifica una espera para el hilo
                   return;
                   } 
                   System.out.println ( "Toc");
                   notify ( );
                   try {
                          wait ( ); // espera que tick ( ) se complete
                   }
                   catch ( InterruotedException exc ) {
                          System.out.println ( "Hilo interrumpido");
                   }
         }
    }

    class MyThread implements Runnable {
             Thread thrd;
             TickTock ttOb;

            // construye un nuevo hilo
            MyThread ( String name.TickTock tt ) {
                    thrd= new Thread ( this.name );
                    ttOb= tt;
                    thrd.start ( ); // arranca el hilo
           }
          //inicia la ejecución del nuevo hilo
          public void main ( ) { // El hilo comienza a ejecutarse aquí
                  if ( thrd.getName ( ).compareTo ( "Tick") == 0 ) {
                       for ( int i=0; i<5; i++ ) ttOb.tick ( true );
                                ttOb.tock ( false );
                 }
                 else {
                      for ( int i=0; i<5; i++ ) ttOb.tock ( true );
                              ttOb.tock ( false );
                 }
          }
    }

    class ThreadCom {
            public static void main ( String args [ ]) {
                      TickTock t1= new TickTock ( );
                      MyThread mt1= new MyThread ( "Tick",tt );
                      MyThread mt2= new MyThread ( "Tock",tt );
                try {
                     mt1.thrd.join ( );
                     mt2.thrd.join ( );
               } catch ( InterruptedException exc ) {
                         System.out.println ( "Procedimiento interrumpido ");
              }
         }
    }
    BIBLIOGRAFIA
    • Fundamentos de programacion en java 2 
             Autor: Schildt, Herbert

            Mc Graw Hill

    INTEGRANTES:
    • Cruz Gonzalez Juan Carlos
    • De la Cruz Alonso Jesús Adrian
    • Lacorte Casimiro Francisco
    • Martínez Feliciano Angelica
    • Vicencio Osorio Daniel Eduardo