Hilos de ejecución

Este tema trata conceptos básicos como lo que son los hilos de ejecución, que tipos existen y las diferencias entre estos, así como también los diferentes estados de los procesos según los hilos que este tiene, ademas de unos ejemplos de uso practico de los hilos. La importancia de este tema, es poder conocerlos y entenderlos para poder crear aplicaciones a partir de hilos y así aprovechar mejor los recursos de nuestra maquina por medio de aplicaciones que se beneficien del paralelismo.

Concurrencia de procesos

Este tema consiste en los conceptos de la concurrencia de procesos, región critica, exclusión mutua, ademas de las soluciones que podemos encontrar para garantizar la exclusión mutua, entre procesos concurrentes, como lo son: Las soluciones por software, hardware y por medio de soporte al sistema operativo; Se tratara a grandes rasgos lo que son los algoritmos de Dekker (soluciones por software) y un resumen de los mismos para poder memorizarlos.

Modelo de procesos

Esta es una clase que hice para el curso de Sistemas Operativos, en la cual se tratan temas básicos como que son los programas, procesos, hilos, y en que se diferencian estos. Ademas de información acerca del modelo de procesos, y como es que le sirve al sistema operativo el manejo de esto para la asignación de recursos.

Si quieren ver la presentación acá la pueden ver ya que la he subido a scribd, igual si la quieren bajar y utilizar para dar una clase, no hay ningún problema ya que esta liberada bajo una licencia CC.

Acá también dejo el contenido del documento, pero no en formato de presentación, sino en formato de recopilación de información, de esta manera es mas fácil y rápido de leer.

Estas son las referencias, utilizadas:

http://es.wikipedia.org/wiki/Programa_(computaci%C3%B3n)
http://es.wikipedia.org/wiki/Software_de_sistema
http://es.wikipedia.org/wiki/Software_de_aplicaci%C3%B3n
http://so-wiki.wetpaint.com/page/Procesos
http://ci.ldc.usb.ve/~spd/Docencia/ci-3821/Tema3/node1.html
http://so-wiki.wetpaint.com/page/BCP%2C+Cambios+e+Interrupciones
http://so-wiki.wetpaint.com/page/Estados+de+procesos [Recomendado para saber más de los diferentes modelos de estados]
http://ci.ldc.usb.ve/~spd/Docencia/ci-3821/Tema3/node2.html [Recomendado para saber mas acerca del modelo de 7 estados de Unix, donde ademas se explica algunas razones para suspender un proceso]

Video de presentacion del sistema DiagNes

Para aquellos que se pregunten que es el Sistema DiagNes, fue el nombre que le puse a mi proyecto final de carrera, en el que tuve que crear una presentación de lo que se trata el mismo, y aprovechando este espacio les pongo el vídeo, donde cualquier idea, sugerencia o critica, es bienvenida.  Lo relacionado con este proyecto, lo iré publicando por acá y en mi canal de youtube [donde también pueden encontrar otras cosas que he hecho].

Semaforos, algoritmos y codigo java

Semáforos

Un semáforo nos sirve para poder permitir o restringir a los procesos o hilos el acceso a algún recurso compartido.

Los semáforos cuentan con dos operaciones básicas, una de ellas es para reservarlo y la otra para liberarlo, wait (espera) y signal (señal) respectivamente, equivalente down y up.

Los semáforos pueden ser binarios o generales.

Existe una tercera operación en los semáforos, que es el inicializador, esta operación definirá si el semáforo será binario o no, es decir, si se inicializa con 1, el semáforo será binario ya que solo podrá manejar un recurso compartido, en caso de tener “N” recursos compartidos se inicializara con “N”. De igual si tenemos “N” procesos inicializamos un semáforo para que solo “N” procesos acceda a un recurso compartido.

La operación “Down” consistirá en ir decrementando el numero de recursos que posee el semáforo, cuando este contador llegue a 0, entonces el proceso quedara bloqueado en espera de que dicho contador sea liberado por medio de un “Up”.

Existen semáforos que tiene la operación de manejar una cola del tipo FIFO (PEPS) para llevar el control de los procesos que están solicitando los recursos, así cuando se liberen los recursos estos puedan asignarle dicho recurso al primer proceso que lo solicito.

Desventajas

  • No se puede imponer el uso correcto de los “Down” y “Up”
  • No existe una asociación entre el semáforo y el recurso
  • Entre “Down” y “Up” el usuario puede realizar cualquier operación con el recurso.

Algoritmo Semáforo

//Para bloquear
Down (semaforo){
__ If semaforo > 0 then
____semaforo=semaforo -1
__ else
____bloquear_el_proceso();
}

//Para liberar
Up (semaforo){
__ if hay_proceso_bloqueado then
____despertar_el_proceso()
__else
____semáforo = semáforo + 1
}

//constructor
Init (semaforo, mum)
__ semaforo=num;
end

Codificacion de Semaforo en Java

public class Semaforo {
__
__private int valor;
__
__/** Creates a new instance of Semaforo */
__public Semaforo(int v) {
____valor = v;
__}
__
__public synchronized void down(){
____while(valor <= 0){
______try{
________wait();
______}catch(InterruptedException e){
________;
______}
____}
____valor–;
__}
__public synchronized void up(){
____valor++;
____notify();
__}
}

Nota: Los “__” representan tabulaciones, ya que wordpress me pega todo a la derecha y no se puede ver bien asi.

Bibliografía utilizada

semáforos en Wikipedia

Conceptos generales

Ejemplo de productor consumidor utilizando semáforo

Estructura de los sistemas operativos

Estructuras de cómo puede ser codificado un sistema operativo.

Sistemas monolíticos

  • Tipo de sistema más común.
  • Todos los componentes se encuentran en un solo programa (El SO), el cual se ejecuta en único espacio de direcciones.
  • Consiste en una colección de procedimientos que se pueden llamar entre sí.
  • Los procedimientos contienen una interfaz bien definida en términos de parámetros y resultados.
  • Los procedimientos (partes del kernel) son compilados de manera individual y luego son enlazados (Manejados por capas).

Deficiencias:

  • No existe la ocultación de la información, ya que todos los procedimientos se pueden “ver” (comunicar) entre sí.

Estructura por microKernel

  • Las funciones centrales de un SO son controladas por el núcleo (kernel).
  • La interfaz del usuario es controlada por el entorno (Shell).
  • Provee llamadas mínimas al sistema operativo.
  • Ventajas: Una falla no arruina a todo el sistema.

Estructura Cliente-Servidor

  • Consiste en trasladar el código a capas superiores, dejando un núcleo mínimo.
  • Pretende implantar la mayoría de las funciones del sistema operativo como procesos de usuario.
  • Los procesos que existen son procesos clientes y procesos servidor.
  • La función del kernel se reduce a funciones básicas como controlar, supervisar y coordinar la comunicación entre los procesos clientes y servidores.

Estructura por capas (anillos concéntricos)

  • Organiza al sistema operativo como una jerarquía de capas.
  • Cada capa ofrece una interfaz clara y definida para la capa superior, y utiliza servicios de la capa inferior.
  • Ofrece una buena modulación y ocultación de la información.
  • Admón. de memoria, admón. De procesos…

Nota: Este es un resumen que hice para mi clase de Sistemas Operativos, pero si quieren abarcar mas de estos temas, estos links son bastante buenos y fue de donde tome la información:

Acerca de varias estructuras en general, tomado de Monografias
Completo acerca de monolítico y cliente-servidor
Micro nucleo, desde Wikipedia
Monolítico, desde Wikipedia

Menu de abrir y guardar archivos

Para que podamos desplegar un pequeño menu de directorio en donde querramos escoger que archivo queremos abrir solo basta usar JFileChooser.  En este caso yo lo hice desde una clase diferente a donde se esta creando el modo grafico, por lo que cada vez que llamemos a este metodo desde nuestra clase de modo grafico es decir de nuestra clase.form deberemos de pasarla como parametro, para esto solo se hace asi:

varInstanciada.abreArchivo(this);

el codigo para que nos muestre la ventanita para escoger el archivo es este:

public String abreArchivo(Imaginacion ima){
//Debe recibir como parametro el modo grafico de donde se manda, basta con mandar this y aqui haber declarado
//aqui el nombre de la clase grafica de la cual se esta llamando, en este caso Imaginacion
//Si no existe el file chooser, crea uno

JFileChooser jFileChooser1;
jFileChooser1 = new javax.swing.JFileChooser();
String url;
String ret;

if (JFileChooser.APPROVE_OPTION == jFileChooser1.showOpenDialog(ima)){
// Llamar a openFile para intentar cargar el texto desde el archivo al JtextArea
url = jFileChooser1.getSelectedFile().getPath();
ret = this.Abrira(url);
}else
ret = “No se pudo abrir el archivo”;

return ret;
}

Este método nos retorna la dirección del archivo que queremos abrir, ya con esta dirección podemos cargar el archivo deseado a un string, esto lo puedes hacer así.

El método para mostrar la ventanita guardar es algo similar, pero como siempre es mas fácil verlo con código, así que aquí esta mi clase, para las ventanitas de abrir, guardar y de leer y escribir en un archivo. Si tienen problema de como instanciarlas(usarlas) no olviden preguntar ¿¿¿como???

Crear archivos de texto java

Con lo de crear quiero indicar escribir sobre un archivo de texto, o ya bien sea, aunque tambien puede crear un archivo de texto y no escribirle nada, aunque no es muy logico, jejeje.  Para hacer esto se puede hacer de varias forma, yo prefiero utilizar un String para mandar a leer y escribir a un archivo, ya que de esa manera puede utilizar el tokenizer y hacer un escanner mas facilmente, aunque si se desea un escanner y parser mas completo se debe de usar herramientas como JLex y Cup (Medio controlo eso por si necesitan ayuda, ojala que me recuerde nada mas, XD).

Para escribir este es un método, llamado Abrirá, al cual le deben de pasar como parámetro la dirección del archivo, este método solo carga el contenido de un archivo de texto desde una ubicacion especifica a un string:

public String Abrira(String Dir){

String Llevo_Texto = new String(“”);
try{
FileReader Carga_Escritura = new FileReader(Dir);
BufferedReader Lev_Text = new BufferedReader(Carga_Escritura);
String Llevo_Otro = new String();

while((Llevo_Otro = Lev_Text.readLine())!=null){

if(Llevo_Texto == null){
Llevo_Texto = Llevo_Otro;
}
if(Llevo_Texto != null){
Llevo_Texto = Llevo_Texto + Llevo_Otro + “\n”;
}
}

Lev_Text.close();
Carga_Escritura.close();
}

catch(FileNotFoundException e){
System.out.println(“El Archivo No se encontro”);
}
catch(IOException e){
System.out.println(“ERROR: No se puede leer el archivo”);
}
return Llevo_Texto;
}

Para llamar a este metodo seria:      VarInstanceada.Abrira(“C:\entrada.txt”);

Si se desea escribir en un archivo de texto, seria:

public boolean  Guardara(String Conte, String Dir){
if(Directo != “”)
Dir = Directo + Dir;

boolean Est;
try{
FileWriter Carga_Escritura = new FileWriter(Dir);
BufferedWriter Lev_Text = new BufferedWriter(Carga_Escritura);

if(Conte == null){
Conte = “”;
}

Lev_Text.write(Conte);
Lev_Text.close();
Carga_Escritura.close();

Est = true;
}

catch(FileNotFoundException e) {
System.out.println(“El Archivo No se encontro”);
Est = false;
}
catch(IOException e){
System.out.println(“ERROR: No se puede leer el archivo”);
Est = false;
}

return Est;
}

Se usa un boolean para validar si se logro guardar o no.  Este metodo crea archivos y les inserta texto, si se desea agregar mas contenido a un archivo bastara con, abrir primero el archivo y guardar el contenido en algun lado y luego volver a crear el archivo (Con el mismo nombre) y escribir lo que tenia antes y luego agregandole lo que deseemos.  Como siempre es mas facil ver esto en codigo, asi que les dejo mi clase de manejar archivo.

Si deseas ver como se hace para abrir ventanitas de abrir y guardar esta este post

Manejo de un array de byte []

Pues tal vez no sea la gran cosa dirán algunos, pero perdí mas de 30 minutos buscando como y no encontraba algo que me sirviera. En si lo que necesitaba era poder manejar el método getDistances() de la clase UltrasonicSensor ya que ando programando un robot de Lego. Este método me devuelve un array de 8 bytes, pero no sabia como leerlos, pero al fin pude convertirlos a int individuales. Acá dejo el código para que vean lo fácil que estaba.

byte[] elbyte = senUl.sonico.getDistances();

for (int a = 0; a < elbyte.length; a++){
int lleva = 0xFF & elbyte[a];
System.out.println(a + “.- ” + lleva);
}
En si, es asi la variable “elbyte” contiene el array de bytes que devuelve el metodo getDistances. Lo metemos a un ciclo que recorra el tamaño de “elbyte” y finalmente lo mas imporntante para convertir cualquier byte o un elemento de un arreglo de byte es con “0xFF & ” y el byte a convertir.

Hola Mundo!!

Que mejor manera de empezar un blog dedicado a temas de informática en general, que con un clásico hola mundo escrito en lenguaje Java.


class HolaMundo(){
static void main(String args[]){
System.out.println("Hola Mundo");
}
}

Pues luego de un F6 (netbeans) o un javac HolaMundo.java desde consola y ver: “Hola Mundo”, solo resta decir estoy acá para compartir lo poco que se, y tratar de aprender resolviendo las dudas que en algún momento me planteen.

Nota: Los post acá no tienen un orden de dificultad, ya que iré posteando conforme se me ocurra o conforme me planteen dudas acá en el blog [vía comentarios] o dudas que me hacen de vez en cuando.