Núcleo de Ferrita

Novedades y propuestas (JSR) en Java 7

2009-03-31T00:23:00.003+02:00

Interesante artículo en el blog de Alex Miller (en inglés) describiendo numerosas novedades propuestas (JSR) que se espera sean incorporadas a Java 7 de la mano de Sun. El autor insiste en que, aunque hay algunas propuestas aprobadas, se trata de algo todavía no oficial, por lo que las incorporaciones de Java 7 pueden no corresponderse exactamente con lo propuesto. Al fin y al cabo Java 7 sigue en desarrollo.

A continuación, describiré alguna de estas propuestas, indicando si han sido aprobadas o no (considero algunas no aprobadas muy interesantes) y facilitando enlaces siempre que me sea posible, aunque recomiendo la lectura del artículo original:

JSR 296 Swing Application Framework (JSR, Proyecto) APROBADA

Proporcionar un framework para aplicaciones Swing, definiendo una infraestructura común a la mayoría de aplicaciones de escritorio. El objetivo es que las aplicaciones Swing resulten mas sencillas de crear.

JSR 295 Beans Binding (JSR, Proyecto) NO APROBADA

Proporcionar un API que permita que dos propiedades de dos beans se mantengan sincronizadas, de forma que si cambia una de las propiedades en uno de los beans, automáticamente se refleje en el otro. En JavaFX sí hay algo parecido...

Type Inference (Propuesta) APROBADA

Simplificar la inicialización de algunas clases como listas o mapas. Por ejemplo, donde antes teníamos:

Map<String, List<String>> anagrams = new HashMap<String, List<String>>();

Ahora tendremos:

Map<String, List<String>> anagrams = new HashMap<>();

Language level XML support NO APROBADA

Permitir introducir XML literal embebido en el código, e incluso otros tipos de texto o lenguajes:

elt.appendChild(
    <muppet>
        <name>Kermit</name>
    </muppet>
);

BigDecimal operator support NO APROBADA

Posibilidad de manipular objetos BigDecimal con operadores aritméticos, como se hace con los tipos primitivos y con muchas de las clases que los representan, como Integer, Long, etc.

Strings in switch statements (Propuesta) SIN DETERMINAR

Posibilidad de utilizar la clase String en una sentencia switch:

static boolean booleanFromString(String s) {
    switch(s) {
        case "true":
            return true;
        case "false":
            return false;
    }
    throw new IllegalArgumentException(s);
}

Comparisons for Enums (Propuesta) SIN DETERMINAR

Permitir operadores lógicos en enumerados:

boolean isRoyalty(Rank rank) {
    return rank >= Rank.JACK && rank != Rank.ACE;
}

Chained invocation (Propuesta) NO APROBADA *

Permitir encadenar fácilmente llamadas a métodos, permitiendo que métodos void devuelvan implícitamente this:

class Factory {
    void setSomething(Something something) { ... }
    void setOther(Other other) { ... }
    Thing result() { ... }
}
...
Thing thing = new Factory()
    .setSomething(something)
    .setOther(other)
    .result();

Extension methods (Propuesta) NO APROBADA *

Permitir utilizar métodos de otras clases utilizando el operador static:

import static java.util.Collections.sort;
List<String> list = ...;
list.sort();
/* Parece que se llama a List.sort(), pero en realidad se está llamando a Collections.sort() */

Enhanced null handling (mi preferida) (Propuesta) APROBADA

Permitir encadenar llamadas a métodos, comprobando automáticamente que los valores devueltos no sean null, lo que provocaría una NullPointerException. Por ejemplo, donde antes teníamos:

public String getPostcode(Person person) {
    if (person != null) {
        Address address = person.getAddress();
        if (address != null) {
            return address.getPostcode();
        }
    }
    return null;
}

Ahora bastará con:

public String getPostcode(Person person) {
    return person?.getAddress()?.getPostcode();
}

Esta misma característica (Propuesta)se podrá utilizar con métodos que pueden devolver null:

String str = getStringMayBeNull();
str = (str == null ? "" : str);

Que pasa a ser:

String str = getStringMayBeNull() ?: "";

Improved catch clause (Propuesta) APROBADA

Poder capturar simultáneamente varios tipos de excepciones:

try {
    return klass.newInstance();
} catch (InstantiationException | IllegalAccessException e) {
    throw new AssertionError(e);
}

G1 Garbage Collector (PDF) APROBADA

G1 es un mejorado recolector de basura de Java que divide el espacio en varias regiones determinadas, permitiendo limpiar memoria en un conjunto de dichas regiones, en vez de partir el espacio en partes arbitarias. En el JDK de Sun de Java 7 esté será, en principio, el recolector de basura por defecto.

(*) El estado de aprobación de algunas propuestas aparece en el artículo original con interrogantes. Tal vez, a pesar de no haber sido aprobadas, tienen todavía posibilidades.

A mi me parecen de lo más interesantes (unas más que otras, claro). En el artículo original hay muchas más, pero la entrada se quedaba demasiado larga, tal vez para una próxima... Desconozco las posibilidades que puedan tener muchas de las propuestas no aprobadas de cara al futuro. Habrá que estar pendientes.

Y disculpad si encontrais algún error en las traducciones!

Gracias a C.A. por el apunte :)
Saludos.

Historia de un Viejo Informático

2009-03-29T17:00:00.000+02:00

Hoy quiero recomendar una serie de excelentes artículos sobre la historia de la informática aplicada en España desde los años 70, contados de primera mano por Mackluskey, alguien que se autodefine como un informático de los tiempos heroicos, que no ha dejado de trabajar en Informática y disfrutar con ella hasta la fecha. Y lo que el cuerpo aguante. Lo de los tiempos heróicos es más que cierto leyendo sus entradas, sobre todo las primeras.

Todavía no he terminado de leerlas todas. Me he quedado a la hora de escribir estas líneas, en la entrada que versa sobre la programación estructurada, la más habitual hasta la llegada de la POO. Sin embargo, ya he leído más que suficiente para decidirme a recomendarlo, especialemente a los informáticos de los últimos años, que no vivimos una época semejante y sobretodo, a los actuales estudiantes de informática.

Si tuviese que elegir una favorita entre las leídas hasta la fecha, aunque difícil, creo que me quedaría con la entrada sobre los mainframes de IBM, curiosamente la que menos se mete en datos antiguos, centrándose más en las máquinas actuales, aunque aclarando luego en los comentarios que, en realidad, se trata de las mismas máquinas elevadas a la enésima potencia. Además, se hace referencia en los comentarios y en entradas posteriores a otra serie de historias dedicadas a dichas máquinas, de la mano de kujaku. Creo que serán mi próxima lectura.

Eso sí, advierto que algunas entradas son muy largas y mucha gente, sobre todo no informáticos, serán incapaces de llegar al final. Aunque hay entradas mas llevaderas que otras.

Totalmente recomendable.

Núcleo de Ferrita

2009-03-28T10:23:00.006+01:00

El nombre de este blog centrado en la Informática (aunque de vez en cuando salte a otros temas) viene dado por la imagen y emblema de la profesión. Lo que no había hecho todavía era dedicar una entrada a este viejo elemento de la computación.

En la wikipedia podemos leer:

La memoria de toros o memoria de núcleos magnéticos, fue una forma de memoria principal de los computadores, hasta comienzos de los años 70. La función de esta memoria era similar a la que realiza la memoria RAM en al actualidad: es el espacio de trabajo, para la CPU, donde se graban los resultados inmediatos de las operaciones que se van realizando. A diferencia de la RAM basada en tecnologías DRAM, se basa en las propiedades magnéticas de su componente activo, el núcleo de ferrita y era una memoria no volátil.

Dicho de otro modo, un núcleo de ferrita era capaz de almacenar la unidad mínima de información (un bit) en la memoria de trabajo de estos ordenadores (lo que hoy sería la RAM). Además, era una memoria no volátil, lo que significa que no perdía su valor tras dejar de recibir alimentación eléctrica, por tratarse de un material magnético.

El emblema es el que desde hoy puede verse a la derecha en este blog. Para ver una descripción de cómo funciona y de qué significa cada una de las "barras" que lo ~~recorren~~ atraviesan (en realidad son cables), nada mejor que la magnífica explicación que Manuel Rovayo García, hace paso a paso en su artículo: Diálogo sobre las memorias de anillos de ferrita.

Si os interesa el tema, que lo disfrutéis :)

Listado de Live CDs para todos los gustos

2009-03-27T23:32:00.002+01:00

En http://www.livecdlist.com/ podemos encontrar innumerables enlaces a Sistemas Operativos LiveCD, orientados a propósitos concretos, la mayoría de ellos basados en distribuciones GNU/Linux.

Al abrir la página aparecerá un listado con todas las distribuciones disponibles, aunque se puede seleccionar en el combo de la parte superior cualquiera de las categorías que se prefiera: escritorio (con distros tan conocidas como Suse, Knoppix o Ubuntu, entre muchas otras), antivirus para windows, astronomía, clustering, desarrollo, diagnóstico, educación, firewall/router, rescate y un largo etcétera.

Gracias a D.F! por el apunte :)

Mis compañeros en South Park

2009-03-23T09:00:00.004+01:00

Antes de nada, decir que esta entrada está íntegramente dedicada a mis compañeros de trabajo, en concreto al equipo de desarrollo de nuestro proyecto, por lo que si no eres uno de ellos, probablemente no te interesará lo más mínimo. Aún así he querido tomarme la libertad de este pequeño homenaje. Si alguien se siente molesto u ofendido por supuesto no tiene más que decirlo y lo retiraré inmediatamente.

Es increíble cómo por casualidad, puedes descubrir en uno de tus contactos de msn un avatar personalizado con la forma clásica de los personajes de South Park (gracias Patri xD) y tras buscar un poco en google y terminar encontrando el sitio (http://www.sp-studio.de/) acabar totalmente entretenido creando muñequitos como un niño pequeño :)

Así que me puse manos a la obra con el que será por ahora el nuevo avatar de este blog:

Creo que no he conseguido un parecido demasiado exagerado, pero al menos es un comienzo. El caso es que luego uno no puede parar, y continúa caricaturizando a su responsable técnico y su jefe de proyecto:

Y al final terminas por caricaturizar a todos tus compañeros:

Reconozco que algunas están un poco pilladas por los pelos (¡que complicado D.F!), pero bueno, espero que todo el mundo se "medio-reconozca" xD Y como traca final, los Pancho Villa's Band en acción:

Nos vemos el lunes! Y que me perdonen los chicos de soporte por no añadirlos, ya no me quedaban ideas :( Tal vez como grouppies... xD

La guerra de dos mundos

2009-03-21T05:18:00.001+01:00

Os habréis fijado que a la derecha, tengo un pequeño apartado dedicado a otros blogs recomendados. Normalmente no hago reseña de ninguna de sus entradas, pues todas suelen ser como mínimo interesantes, y por eso figuran ahí. Sin embargo, el artículo que he leído hoy en historias de la ciencia me ha llamado la atención especialmente: la guerra de dos mundos.

Si os gusta escrutar las películas de ciencia ficción en busca de patadas a las leyes de la física (¿quién no ha comentado alguna vez que las explosiones de La Guerra de las Galaxias no deberían oírse?) seguramente el libro que se comenta en el artículo será de vuestro interés, muy al estilo de otro de los blogs que recomiendo: malaciencia. Por lo pronto el resumen de omalaled sirve para abrir boca.

Totalmente recomendable.

Instalación y configuración de conky en ubuntu

2009-03-20T02:46:00.002+01:00

¡Hola! sí, sigo vivo. Hoy ha sido festivo y he tenido tiempo para trastear un poco. Hace cosa de un mes me instalé una ubuntu con la que estoy bastante contento (ya había usado antes otras distros GNU/Linux, pero hace tiempo). El caso es que, visitando Linux Zone, me encontré un artículo sobre conky, un software de monitorización del sistema de lo más ligero. En definitiva, uno de esos programas que había visto funcionando en multitud de pantallazos de escritorio, pero con los que nunca me había metido.

Hasta hoy estaba utilizando gDesklets, que permite añadir muchísimos widgets para infinidad de tareas, desde visualizar la temperatura y el clima de una ciudad, hasta monitorizar la carga de tu interfaz de red, por poner dos ejemplos. El problema es que el portátil con el que trabajo ya tiene sus años y resultaba algo pesado. Por ello, como decía, he dado el paso y he desinstalado tanto gDeskelts como AWN. Éste último lo he substituído por Gnome Do con su apariencia de docky, pero esa ya es otra historia.

Para instalarlo no hay que hacer nada especial, ya que viene por defecto en los repositorios de ubuntu:
$ sudo aptitude install conky

Una vez instalado, podemos ejecutarlo directamente con la orden conky. El aspecto inicial es el mostrado en el artículo de Linux Zone mencionado:

Para editar tanto la apariencia como las opciones que aparecen, disponemos de una completa colección de ejemplos y documentación en la web oficial del proyecto. Especialmente útil el apartado de variables disponibles, ya que son fundamentales para la configuración de conky.

Cuando se ejecuta el programa, se busca por defecto un script en $HOME/.conkyrc. Si el script no existe, se muestra el aspecto que ya hemos visto. Para configurar la apariencia de conky debemos editar o crear dicho fichero con el script que deseemos, aunque podemos hacer funcionar conky con cualquier otro script utilizando el parámetro -c:
$ conky -c myscript

Tras algunos problemas, como el hecho de que me hiciese desaparecer los iconos del escritorio, o que no me funcionasen las variables del audacious, conseguí dar con la configuración necesaria para adaptarlo a mi gusto, a partir eso sí, de uno de los ejemplos de la web, cuyo script podemos descargar aquí.

Este es el resultado final, a ver qué os parece (clic para ampliar):

Y aquí el script que lo genera:


# copy at $HOME/ with filename .conkyrc or execute conky -c filename
# conky configuration
# edited by darcon@gmail.com

# reedited by jfmillan@gmail.com:
# changed some colours, texts, intervals..
# added wireless data
# added audacious data if running

# set to yes if you want Conky to be forked in the background
background yes 

# X font when Xft is disabled, you can pick one with program xfontsel
#font 5x7
#font 6x10
#font 7x13
#font 8x13
#font 9x15
#font *mintsmild.se*
#font -*-*-*-*-*-*-34-*-*-*-*-*-*-*


# Use Xft?
use_xft yes

# Xft font when Xft is enabled
#xftfont Bitstream Vera Sans Mono:size=8
#xftfont Terminus:size=8
xftfont Monospace:size=8

# Text alpha when using Xft
xftalpha 0.8

# Print everything to console?
# out_to_console no

# mail spool
# mail_spool $MAIL

# Update interval in seconds
update_interval 3.0

# This is the number of times Conky will update before quitting.
# Set to zero to run forever.
total_run_times 0

# Create own window instead of using desktop (required in nautilus)
own_window yes
own_window_type override

# Use double buffering (reduces flicker, may not work for everyone)
double_buffer yes

# Minimum size of text area
minimum_size 10 5

# Draw shades?
draw_shades yes

# Draw outlines?
draw_outline no 

# Draw borders around text
draw_borders no

# Stippled borders?
stippled_borders 0

# border margins
border_margin 4

# border width
border_width 1

# Default colors and also border colors
default_color white
default_shade_color black
default_outline_color white

# Text alignment, other possible values are commented
alignment top_left
#alignment top_right
#alignment bottom_left
#alignment bottom_right

# Gap between borders of screen and text
# same thing as passing -x at command line
gap_x 5
gap_y 1

# Subtract file system buffers from used memory?
no_buffers yes

# set to yes if you want all text to be in uppercase
uppercase no

# number of cpu samples to average
# set to 1 to disable averaging
cpu_avg_samples 1

# number of net samples to average
# set to 1 to disable averaging
net_avg_samples 1

# Force UTF8? note that UTF8 support required XFT
override_utf8_locale no


# Add spaces to keep things from moving about?  This only affects certain objects.
use_spacer yes
#Note: doesn't work in conky 1.2 =(

#   mldonkey_hostname     Hostname for mldonkey stuff, defaults to localhost
#   mldonkey_port         Mldonkey port, 4001 default
#   mldonkey_login        Mldonkey login, default none
#   mldonkey_password     Mldonkey password, default none

# stuff after 'TEXT' will be formatted on screen

TEXT







${offset 12}${color slate grey}Date..: ${color}${time %a, }${time %e %B %G}
${offset 12}${color slate grey}Time..: ${color}${time %Z, }${time %H:%M:%S}
${offset 12}${color slate grey}UpTime: ${color}$uptime
${offset 12}${color slate grey}Kernel: ${color}$kernel
${offset 12}${color slate grey}CPU...: ${color}$machine   $freq MHz
${offset 12}${color slate grey}Load..: ${color}$cpu%   ${acpitemp}C
${offset 12}${color slate grey}Proc..: ${color}$running_processes / $processes 
${offset 12}${cpugraph 20,155 ffff00 ddaa00}

${offset 12}${color slate grey}Processor:
${offset 12}${color #ddaa00} ${top name 1}${top_mem cpu 1}
${offset 12}${color lightgrey} ${top name 2}${top cpu 2}
${offset 12}${color lightgrey} ${top name 3}${top cpu 3}
${offset 12}${color lightgrey} ${top name 4}${top cpu 4}

${offset 12}${color slate grey}Memory:
${offset 12}${color #ddaa00} ${top_mem name 1}${top_mem mem 1}
${offset 12}${color lightgrey} ${top_mem name 2}${top_mem mem 2}
${offset 12}${color lightgrey} ${top_mem name 3}${top_mem mem 3}
${offset 12}${color lightgrey} ${top_mem name 4}${top_mem mem 4}

${offset 12}${color slate grey}RAM.: ${color}$memperc% $mem / $memmax
${offset 13}${membar 3,155}
${offset 12}${color slate grey}SWAP: ${color}$swapperc% $swap/ $swapmax
${offset 13}${swapbar 3,155}
${offset 12}${color slate grey}DiSK: ${color}${fs_free /}/ ${fs_size /}
${offset 13}${fs_bar 3,155 /}

${offset 12}${color slate grey}Wireless: ${color}${wireless_essid eth1}
${offset 12}${color #ddaa00} IP....: ${color}${addr eth1}
${offset 12}${color #ddaa00} Device: ${color}eth1
${offset 12}${color #ddaa00} Signal: ${color}${wireless_link_qual_perc eth1}%

${offset 12}${color}Up:   ${color}${upspeed eth1} k/s
${offset 12}${upspeedgraph eth1 20,155 ffff00 ddaa00}
${offset 12}${color}Down: ${color}${downspeed eth1} k/s${color}
${offset 12}${downspeedgraph eth1 20,155 ffff00 ddaa00}

${if_running audacious}
${offset 12}${color slate grey}${exec audtool version}: ${color}
${offset 12}${color #ddaa00} Artist: ${color}${execi 3 audtool current-song | cut -d "-" -f1}
${offset 12}${color #ddaa00} Title.:${color}${execi 3 audtool current-song | cut -d "-" -f2}
${offset 12}${color #ddaa00} Time..: ${color}${execi 3 audtool current-song-output-length} / ${execi 3 audtool current-song-length} (${execi 3 audtool playback-status})
${offset 12}${color #ddaa00} Song..: ${color}${execi 3 audtool playlist-position} / ${execi 3 audtool playlist-length}  ${color #ddaa00}Vol: ${color}${execi 21 audtool get-volume}%
${endif}

Como se puede observar, el código de monitorización de audacious está incluida en un if_running. Sólo se muestra cuando dicha aplicación está funcionando.

Hasta pronto, espero.

50 renders de lo más impresionante

2009-02-07T18:42:00.004+01:00

No es ningún misterio que la informática avanza en todos los frentes que pueda tener abiertos. Uno de ellos es el diseño gráfico, con programas como el 3DMax y el Photoshop al que miles de modelos deben estar más que agradecidas (y agradecidos). Vía Yonkis [+18] me encuentro una web con los 50 mejores renders... ¿del año? no lo sé.

Aquí el enlace. Por si os da pereza pinchar, pongo unos ejemplos (no todas tienen esta calidad, pero merece la pena echar un vistazo). Que lo disfruteis.

(Nota: las imágenes mostradas son propiedad de sus autores. No se les aplica la misma licencia Creative Commons que al resto de la Web).

En pocas líneas...

2009-01-21T21:51:00.003+01:00

Hola de nuevo.

Hoy me gustaría mostraros algunos programas que me he encontrado buceando por la web de Yo, programador, todos ellos con un factor en común: su reducido número de líneas o bytes.

En los títulos teneis los enlaces a la entrada de Yo, programador:

Programa en Python para resolver un Sudoku


def r(a):i=a.find('0');~i or exit(a);[m

in[(i-j)%9*(i/9^j/9)*(i/27^j/27|i%9/3^j%9/3)or a[j]for

j in range(81)]or r(a[:i]+m+a[i+1:])for m in'%d'%5**18]

from sys import*;r(argv[1])

Servidor web en Bash


#!/bin/bash

# web.sh -- http://localhost:9000/hello?world



RESP=/tmp/webresp

[ -p $RESP ] || mkfifo $RESP



while true ; do

( cat $RESP ) | nc -l -p 9000 | (

REQ=`while read L && [ " " "<" "$L" ] ; do echo "$L" ; done`

echo "[`date '+%Y-%m-%d %H:%M:%S'`] $REQ" | head -1

cat >$RESP <<EOF

HTTP/1.0 200 OK

Cache-Control: private

Content-Type: text/plain

Server: bash/2.0

Connection: Close

Content-Length: ${#REQ}



$REQ

EOF

)

done

Código original aquí.

Tetris básico en 560 bytes


<html>

<head>

<meta http-equiv="Content-Type" content="text/html; charset=shift_jis">

<body onKeyDown=K=event.keyCode><script>X=[Z=[B=A=12]];h=e=K=t=P=0;function Y()

{C=[d=K-38];c=0;for(i=4;i--*K;K-13?c+=!Z[h+p+d]:c-=!Z[h+(C[i]=p*A-Math.round(p/

A)*145)])p=B[i];!t|c+4?c-4?0:h+=d:B=C;for(f=K=i=0;i<4;f+=Z[A+p])X[p=h+B[i++]]=1

if(e=!e){if(f|B){for(l=228;i--;)Z[h+B[i]]=k=1;for(B=[[-7,-20,6,17,-9,3,6][t=++t

%7]-4,0,1,t-6?-A:-1];l--;h=5)if(l%A)l-=l%A*!Z[l];else for(P+=k++,j=l+=A;--j>A;)

Z[j]=Z[j-A]}h+=A}for(i=S="";i<240;X[i]=Z[i]|=++i%A<2|i>228)i%A?0:S+="<br>",S+=X

[i]?"■":"＿";document.body.innerHTML=S+P;Z[5]||setTimeout(Y,99-P)}Y()</script>

</body>

</html>

Ajedrez con IA en 5KB
De este último no tengo el código, y es sin duda el más extenso, pero es que es un ajedrez...

El servidor web y el que resuelve sudokus no los he probado, pero para los otros hay 'plug and play' ;)

Como mínimo, curiosos.

Ejemplo modelo Productor-Consumidor en Java

2009-01-19T01:29:00.000+01:00

Bueno, a actualizar que van siendo horas. En primer lugar, pedir disculpas por la tardanza a mis lectores habituales (¡JA!) pero cuando el tiempo aprieta hay que priorizar :)

Hoy vamos a ver un ejemplo de modelo Productor-Consumidor, que como sabéis representa un problema típico de sincronización en el que tenemos por un lado un hilo que produce datos a procesar y otro hilo que los recoge. Los problemas aparecen por ejemplo, al no poder garantizar que el productor producirá a suficiente velocidad para el consumidor, o viceversa, al no poder garantizar que el consumidor se encontrará siempre algún dato que procesar, con lo que podría estar procesando repetidas veces el mismo dato, o detenerse, etc.

En Java tenemos una clase muy útil que nos permite implementar muy fácilmente este modelo. Se trata de la clase LinkedBlockingQueue, consistente en una cola bloqueante, la cual se comporta de forma que si intentamos recuperar un dato cuando está vacía, se queda esperando, mientras que si tiene algún dato lo devuelve inmediatamente.

Con esto se consigue que el hilo productor pueda producir a su ritmo, almacenando en la cola, mientras el hilo consumidor recoge los datos cuando los haya, quedándose a la espera cuando no.

Veamoslo con un ejemplo. Considero que el código está lo suficientemente comentado, pero de todas formas lo explicaré con más detalle:


package productor.consumidor;



import java.util.Random;

import java.util.concurrent.LinkedBlockingQueue;



/**

 * Ejecuta tareas en segundo plano a medida que le van llegando a una cola de

 * tareas.

 * 

 * @author McQueen

 */

public class BackgroundThread extends Thread {

 /**

  * Cola bloqueante de tareas. Cuando se intenta obtener un elemento de dicha

  * cola y ésta está vacía, se queda a la espera de que se añada algún

  * elemento.

  */

 private static LinkedBlockingQueue<Task> taskQueue = null;



 /**

  * Detendremos la tarea un tiempo aleatorio para simular una tarea costosa

  * para el sistema.

  */

 private static Random random = new Random(System.currentTimeMillis());



 /**

  * Constructor, inicializa la cola bloqueante.

  */

 public BackgroundThread() {

  taskQueue = new LinkedBlockingQueue<Task>();

 }



 /**

  * Prepara una tarea almacenandola en la cola, para ejecutarla tan pronto

  * "le toque".

  */

 public void executeTask() {

  Task task = new Task();

  taskQueue.add(task);

 }



 /**

  * Ejecuta la tarea del hilo.

  */

 public void run() {

  int time = 0;

  while (true) {

   try {

    /* Esperamos a que se pueda ejecutar la tarea. */

    Task task = taskQueue.take();

    /* Se ejecuta. */

    task.execute();

    time = random.nextInt(100) + 1;

    /* Se duerme el hilo varios milisegundos (entre 1 y 100) */

    sleep(time);

    System.out.println("Ejecutada tarea en " + time

      + " milisegundos");

   } catch (InterruptedException e) {

    System.out.println("Hilo interrumpido");

   }

  }

 }

}



/**

 * Clase que realiza una tarea concreta. Se retarda un tiempo para que el

 * ejemplo tenga sentido.

 */

class Task {

 void execute() {

  System.out.println("Ejecutando nueva tarea");

 }

}

Esta clase tiene un método executeTask que, pese a su nombre, no ejecuta realmente la tarea, sino que la encola a la espera de que pueda ejecutarse (las tareas se ejecutan de una en una, ya que las estamos lanzando todas en un mismo hilo). Para crear las tareas he utilizado una clase de ejemplo Task, pero sobra decir que hay mil formas de hacerlo.

A continuación el método run que ejecuta el código principal del hilo, simplemente intenta recoger un elemento (una tarea, una Task) de la cola. Si lo consigue, continúa. Si no lo consigue, se queda a la espera. Una vez lo consigue se ejecuta la tarea (en este caso solo se muestra una línea por consola).

A continuación viene el código que normalmente sobraría en una aplicación real, y que utilizamos para simular un proceso costoso en tiempo, durmiendo el hilo consumidor entre 1 y 100 milisegundos de forma aleatoria (por darle algo más de dinamismo xD).

La InterruptedException que se puede producir notificaría que se ha interrumpido el hilo por ejemplo por algún otro hilo distinto (ya estuviese esperando, ejecutando...). Si se produce puede avisarse a algún método del evento, mostrar algún error, iniciar otro hilo que ejecute alguna otra tarea, detener la aplicación, o, simplemente, no hacer nada.

A continuación veremos el código correspondiente a la parte productora. En este caso lo hemos puesto directamente en el Main, pero evidentemente podría estar en otra clase específica.


package productor.consumidor;



public class Main {

 public static void main(String[] args) {

  int n = 10;

  BackgroundThread back = new BackgroundThread();



  /*

   * Con 'true' se evita que el programa siga en ejecución si el hilo

   * principal termina, por eso no llegan a ejecutarse todas las tareas.

   * 

   * Con 'false' el hilo en background se sigue ejecutando aunque el hilo

   * principal termine, por tanto se ejecutan todas las tareas.

   */

  back.setDaemon(false);



  /* Comenzamos el hilo. */

  back.start();



  while (n > 0) {

   System.out.println("Añadiendo tarea, quedan " + n + " tareas");

   back.executeTask();

   n--;

  }



  /*

   * OJO, si hemos puesto el setDaemon a false el programa sigue

   * ejecutandose aún al llegar al final del Main (el hilo en background

   * seguirá esperando tareas indefinidamente).

   */

 }

}

Simplemente creamos el hilo y lo iniciamos. Lanzamos 10 tareas dentro de un bucle, de forma que se van almacenando en la cola y ejecutando tan pronto como les sea posible.

La salida por consola en un caso así dependerá de la máquina y de si toqueteamos y jugamos con los milisegundos y con el número de tareas a ejecutar.

Atención a la línea back.setDaemon(false);. Como bien cuentan desde Sun, "The Java Virtual Machine exits when the only threads running are all daemon threads" o lo que es lo mismo, la máquina virtual termina cuando los únicos hilos en ejecución son hilos "daemon".

Por lo tanto, si el hilo lo ejecutamos como "daemon" (true), en cuanto el hilo principal llegue al final la aplicación terminará, y no llegarán a ejecutarse todas las tareas de la cola. A continuación la salida mostrada en mi máquina (en una de tantas ejecuciones, ya que el resultado varía).


Añadiendo tarea, quedan 10 tareas
Ejecutando nueva tarea
Añadiendo tarea, quedan 9 tareas
Añadiendo tarea, quedan 8 tareas
Añadiendo tarea, quedan 7 tareas
Añadiendo tarea, quedan 6 tareas
Añadiendo tarea, quedan 5 tareas
Añadiendo tarea, quedan 4 tareas
Añadiendo tarea, quedan 3 tareas
Añadiendo tarea, quedan 2 tareas
Añadiendo tarea, quedan 1 tareas
Ejecutada tarea en 19 milisegundos
Ejecutando nueva tarea

Comienza dos tareas pero solo llega a finalizar una. Las otras 9 quedan sin ejecutarse y el programa se termina.

Si ejecutamos el programa con setDaemon (false) como en el ejemplo, el hilo consumidor sigue corriendo aunque el Main haya finalizado, por lo que se llegan a ejecutar todas las tareas.


Añadiendo tarea, quedan 10 tareas
Ejecutando nueva tarea
Añadiendo tarea, quedan 9 tareas
Añadiendo tarea, quedan 8 tareas
Añadiendo tarea, quedan 7 tareas
Añadiendo tarea, quedan 6 tareas
Añadiendo tarea, quedan 5 tareas
Añadiendo tarea, quedan 4 tareas
Añadiendo tarea, quedan 3 tareas
Añadiendo tarea, quedan 2 tareas
Añadiendo tarea, quedan 1 tareas
Ejecutada tarea en 19 milisegundos
Ejecutando nueva tarea
Ejecutada tarea en 66 milisegundos
Ejecutando nueva tarea
Ejecutada tarea en 58 milisegundos
Ejecutando nueva tarea
Ejecutada tarea en 3 milisegundos
Ejecutando nueva tarea
Ejecutada tarea en 90 milisegundos
Ejecutando nueva tarea
Ejecutada tarea en 3 milisegundos
Ejecutando nueva tarea
Ejecutada tarea en 61 milisegundos
Ejecutando nueva tarea
Ejecutada tarea en 48 milisegundos
Ejecutando nueva tarea
Ejecutada tarea en 90 milisegundos
Ejecutando nueva tarea
Ejecutada tarea en 57 milisegundos

En este caso, incluso cuando se han ejecutado las 10 tareas el hilo sigue ejecutándose a la espera de nuevas tareas que en este caso nunca llegarán.

Como siempre espero que a alguien le sirva.
Saludetes y hasta el mes que viene (que nooooo, intentaré actualizar antes xD).

Repaso a los fogonazos de 2008

2008-12-22T02:40:00.004+01:00

Aprovechando que se termina el año, uno de los mejores blogs hispanos, Fogonazos, hace recopilación de los mejores fogonazos de 2008. Para quien no conozca este blog, sólo decir que muy rara es la entrada que no se merece sobradamente el tiempo que requiera leerla y ver los videos adjuntos. Como muestra un botón (de tantos).

Una joya de la blogosfera de esas que enganchan a esto de Internet. Enhorabuena Fogonazos, enhorabuena Aberron... y gracias por tu desinteresado esfuerzo.

Saludos y que lo disfruteis ;)

Joe Satriani demanda a Coldplay por plagio

2008-12-20T00:26:00.008+01:00

Bueno, parece que la media de retraso en enterarme de lo que pasa por el mundo ronda el mes, pero es lo que tiene estar actualmente sin internet en casa... creo que elegí un mal momento para empezar un blog :)

Hoy he visto en una antigua noticia del diario Público y en algún que otro blog como ¡Tres, dos o uno!, que Joe Satriani ha demandado a la banda británica Coldplay por plagio en su exitoso tema Viva la vida con el que opta a varios Grammy en 2009.

La canción de Satriani que parece haber "insipirado" el tema de Coldplay es If I Could Fly. Los británicos se han apresurado a desmentirlo, pero creo que cada uno ha de tomar sus propias conclusiones.

¿Crees en las casualidades?

La Crisis Ninja

2008-12-07T18:58:00.001+01:00

Hola de nuevo. Cuando miré el correo esta mañana me encontré un vídeo que me había mandado un compañero (gracias Diego) en el que, durante el programa Buenafuente del canal de televisión La Sexta, se pedía a Leopoldo Abadía que resumiese cómo hemos llegado a esta situación de crisis en la que nos encontramos, hablando de lo que él llama La Crisis Ninja.

La verdad es que el video ya es de hace unos meses, pero creo que a quien todavía no lo haya visto ni tenga muy claro cómo hemos llegado a esta situación le aclarará un poco el tema, porque casi todos hemos oído hablar de las hipotecas subprime, pero ¿sabemos realmente lo que son?

Y como no, me he puesto a buscar un poco más y he dado con este otro video del mismo canal, pero del programa Caiga Quién Caiga.

En cualquier caso, creo que mi preferido ha sido éste último, en inglés pero subtitulado al castellano. Espeluznante el final.

En fin, por lo pronto les pongo la etiqueta de Humor. Espero que no pase mucho tiempo hasta que podamos ver estos videos y reírnos realmente (y no por no llorar) recordando tiempos más difíciles.

Saludos.

Ordenar una lista de objetos en Java

2008-12-06T01:04:00.001+01:00

Cuando uno se decide a iniciarse en la programación, una de las primeras cosas "complicadas" que aprende es a ordenar listas y a hacer búsquedas en dichas listas, sobre todo en listas previamente ordenadas.

Todo ello es algo básico y fundamental que se debe aprender sí o sí. Sin embargo, a la hora de tener que ordenar una lista en una aplicación más compleja, lo normal es utilizar alguno de los métodos que pueda facilitar el lenguaje, y ya se sabe que Java nos ofrece una api muy completa con la que se puede hacer prácticamente de todo.

Lo que vamos a ver hoy es la clase de métodos estáticos Collections. Esta clase tiene métodos para ordenar listas, desordenarlas aleatoriamente, hacer búsquedas binarias, obtener el máximo/mínimo elemento, copiar elementos, invertirlos, frecuencia de un elemento... infinidad de posibilidades.

Evidentemente puede compararse/ordenarse/buscarse en listas de cualquier tipo de objeto, pero entonces, ¿como sabe Java que un elemento de la lista es "menor" que otro para poder ordenarlos?

Bien, la lista puede ser de dos tipos de clases:

Clases que heredan de Comparable.
Resto de clases.

Para conseguir ordenar la lista, la clase Collections hace uso del método compare, donde se especifica qué elemento es mayor o menor que otro. Cuando se utiliza una clase que extiende a Comparable (como por ejemplo Integer), intrínsicamente esa clase ya lleva implementado el método compare. Cuando se utiliza por ejemplo, una clase personalizada de las que podemos crear en nuestros programas, podemos utilizar la ayuda de un Comparator, al que le implementamos el método compare y que debemos facilitar a la hora de ordenar la lista.

Veámoslo con un ejemplo de ordenación, primero con una lista de enteros, y luego con una lista de otra clase. Para rellenar las listas utilizaremos números aleatorios con la ayuda de Random.


List<Integer> numbers = new ArrayList<Integer> ();
int n = 10; // número de elementos en la lista
int max = 100; // máximo elemento posible

// Creamos la semilla aleatoria.
Random random = new Random (System.currentTimeMillis());

while (numbers.size() < N) {
    // Integer extiende a Comparable
    numbers.add(new Integer (random.nextInt(max)));
}
  
System.out.println("Sin ordenar: " + numbers);
Collections.sort(numbers);
System.out.println("Ordenado...: " + numbers);

Este ejemplo visualizará la lista desordenada y luego ordenada de menor a mayor.

Imaginemos ahora que queremos ordenarla de mayor a menor. Una manera de hacerlo puede ser ayudarnos de la clase anteriormente mencionada Comparator, definiendo la ordenación de enteros a la inversa de como está por defecto. El método compare devuelve un número menor que cero si el primer elemento es menor que el segundo, mayor que cero si el primer elemento es mayor que el segundo, e igual a cero si ambos elementos son iguales.


Comparator<Integer> comparator = new Comparator<Integer> () {
    public int compare(Integer a, Integer b) {
        return b-a;
    }
};
// Ahora ordenamos utilizando el comparador  
Collections.sort(numbers, comparator);

Veamos otro ejemplo con una clase propia CustomPoint2D:


class CustomPoint2D {
    private int x;
    private int y;
 
    CustomPoint2D (int x, int y) {
        this.x = x;
        this.y = y;
    }
 
    // ... getters, setters... 

    public String toString () {
        return "{" + x + ", " + y + "}";
    }
}

Podríamos ordenarlo definiendo por ejemplo, que un CustomPoint2D es menor que otro si la suma de sus puntos x e y es menor que la del segundo objeto.


List <CustomPoint2D> points = new ArrayList <CustomPoint2D> ();
while (points.size() < N) {
    points.add(new CustomPoint2D (random.nextInt(max), random.nextInt(max)));
}
  
Comparator <CustomPoint2D> comparatorPoint = new Comparator<CustomPoint2D> () {
    public int compare (CustomPoint2D p, CustomPoint2D q) {
        return (p.getX() + p.getY()) - (q.getX() + q.getY());
    }
};
  
System.out.println("Sin ordenar: " + points);
Collections.sort(points, comparatorPoint);
System.out.println("Ordenado...: " + points);

¿Alguna duda?

Agradecimientos por la idea y algún ejemplo para este post a mis compañeros Diego F. y Carlos A.

Crear una caché básica en Java

2008-11-28T19:00:00.018+01:00

Hola, para ir rompiendo el hielo vamos a empezar con algo sencillo. Imaginemos que en nuestra aplicación necesitamos acceder con frecuencia a un dato o registro que podemos identificar por un código, bien sea numérico, alfanumérico...

Como sabemos, los accesos a disco o a Base de Datos son más lentos que en memoria. Empeorémoslo imaginando que para obtener todos los datos del código necesitamos hacer varios accesos o cruzar un número elevado de tablas.

La solución a esto puede ser la creación de una caché. En este caso crearemos una caché en la que mantendremos los datos por antigüedad. En una caché propiamente dicha se almacenan un número determinado de datos (por ejemplo 100 registros). Vamos a ver como crear fácilmente una clase Java que implemente una caché de un máximo de N elementos, de forma que cuando hayamos introducido N+1, se elimine automáticamente el elemento más antiguo.


package cache;

import java.util.LinkedHashMap;
import java.util.Map;

/**
* Caché de datos implementada como LinkedHashMap.
*/

public class Cache<K, V> extends LinkedHashMap<K, V> {

   /** Límite de elementos en caché. */
   private int limit;

   /**
    * Constructor.
    *
    * @param limit
    *            Limite máximo de elementos que tendrá la caché.
    */
   public Cache(int maxLimit) {
       this.limit = maxLimit;
   }

   /**
    * Elimina la entrada más antigua de la caché en el momento de introducir
    * una nueva entrada, sólo cuando se ha alcanzado el límite establecido.
    */
   protected boolean removeEldestEntry(Map.Entry eldest) {
       return size() > this.limit;
   }
}

Como veis, es tan simple como extender la clase LinkedHashMap y sobrecargar el método removeEldestEntry, de forma que cuando el número de elementos supere el límite, devuelva true. Cuando este método devuelve verdadero, automáticamente se elimina el elemento más antiguo. Este método se ejecuta internamente cada vez que se introduce algo en el Map (con put y putAll). Evidentemente si no se sobrecarga, por defecto devuelve siempre false, por lo que nunca se borraría nada.

Una vez implementada, la caché se utiliza de la misma forma que cualquier Map:


/*
 * Crear una nueva cache de 100 elementos, con código Integer y
 * contenido String (clave y valor pueden ser de cualquier clase).
 */
Cache <Integer, String> miCache = new Cache<Integer, String>(100);
  
// para guardar un dato
cache.put(2, "Juan Fernandez");
  
/* 
 * Ahora busquemos un código, suponiendo que si no lo encontramos
 * debemos buscarlo por ejemplo en base de datos.
 */
int codigo = 34;
String nombre = cache.get(codigo);
if (nombre == null) {
    nombre = ... /* buscar en BD */
    /* una vez obtenido, lo guardamos en cache por si se vuelve a pedir. */
    cache.put(codigo, nombre);
}

Espero que a alguien le sirva de algo. Simplemente añadir que yo no me he inventado nada, la documentación de la api de Java es una de las grandes bazas de este lenguaje, y si se busca un poco, se encuentra solución a muchísimos problemas: Clase LinkedHashMap

Inauguración del sitio

2008-11-28T18:36:00.000+01:00

Hola! A pesar de mi profesión en el mundillo de la informática, este es el primer blog que escribo. Espero no aburriros demasiado y ganarme vuestra compañía. La temática del blog será variada, y consistirá sobre todo en compartir mis conocimientos de Informática, mis gustos musicales, noticias que me hayan llamado la atención, etc.

Espero poder llevar un buen ritmo de actualización, aunque me temo que no siempre será posible. Paciencia por favor ;-)

Bienvenid@s.