Volatile: cosa vuol dire in Java?

Spesso accade durante una interview che venga chiesto cosa sia e cosa voglia dire la keyword "volatile" in Java. Questa parola è usata per indicare ad un Thread di non memorizzare il valore di una variabile nella cache ma direttamente nella memoria principale. Perché? Ora immaginiamo che il Thread A modifichi il valore della variabile "pippo". Se il Thread B deve leggere il valore di tale variabile potrebbe accadere che il suo valore non sia stato ancora aggiornato con le modifiche di A. Con la parola chiave volatile si forza il Thread A a rendere visibili gli aggiornamenti fatti immediatamente.
Ora proviamo a vedere un esempio.


public class Singleton{private static volatile Singleton _instance;
public static Singleton getInstance(){
   if(_instance == null){
            synchronized(Singleton.class){              
              if(_instance == null)
                  _instance = new Singleton();
            }
   }
   return _instance;
}

Se non rendiamo la variabile _instance volatile allora il Thread che sta creando l'istanza di "SIngleton", non è in grado di comunicare a gli altri Thread che l'istanza è stata creata fino a che non finirà l'esecuzione del blocco singleton; quindi se il A sta creando un istanza di Singleton e appena dopo la creazione perde la CPU allora tutti gli altri Thread non saranno in grado di vedere il valore della variabile _instance come non nullo e crederanno che il suo valore sia ancora null.

Infine da ricordare che la parola chiave volatile è valida solo per le variabili. Questa differenzia la parola chiave volatile dalla parola chiave synchronized. 

Java ecologico: le variabili d'ambiente e il CLASSPATH

Quando si parla di compilazione di codice Java sicuramente vi sarà capitato di sentir parlare di variabili d'ambiente e CLASSPATH. Il classpath si riferisce al percorso sul tuo file system dove i tuo file .class sono salvati. Il classpath è definito dalla variabile d'ambiente CLASSPATH. Il CLASSPATH specifica le directory e i file JAR dove il compilatore e la JVM troveranno il bytecode. Attraverso l'utilizzo del CLASSPATH si permette di memorizzare il bytecode in directory a nostra scelta o in archivi Java (JAR File).

Rendi ecologico il tuo pc con le variabili d'ambiente..

Per esempio supponiamo di avere la classe com.bustapaga.Impiegato. Il compilatore e la JVM cercheranno la directory \com\bustapaga basandosi sulla variabile d'ambiente CLASSPATH. Quindi se per esempio il file Impiegato.class si trova nella directory

c:\Documents and Settings\Alex\workspaces\build\com\bustapaga

allora la variabile CLASSPATH deve includere la directory

c:\Documents and Settings\Alex\workspaces\build

La variabile CLASSPATH può contenere un qualsiasi numero di directory e file JAR.

Ma come settare questa variabile d'ambiente? Dipende ovviamente dal sistema operativo.

Sotto un sistema Windows: aprire il prompt dei comandi e settare la variabile classpath con questa istruzione (separando i multi valori con il punto e virgola)

set CLASSPATH=”c:\Documents and Settings\Alex\workspaces\build”;
c:\myproject\build;c:\tomcat\lib\servlet.jar;.;

Sotto un sitema Unix: usare il comando setenv per separare valori multipli

setenv CLASSPATH /usr/build:/myproject/build:/tomcat/lib/servlet.jar

Attenzione! Un errore comune da evitare è quello di includere parte del nome del percorso del package nella variabile CLASSPATH. Da evitare ad esempio un errore simile:

set CLASSPATH=c:\myproject\build\com\bustapaga;

Che tipi! Primitive Types vs. Reference Types

Le applicazioni Java prevedono due tipi di dati: primitivi e referenziati. I tipi primitivi sono i classici tipi di dati che si imparano sin dalle prime lezioni di programmazione e sono riassunti nella tabella qui sotto.

La tabella mostra anche i diversi range di valori permessi per ogni tipo. Difficile ricordare ogni singolo range mentre può essere molto utile ricordare la dimensione in bits prevista per ogni tipo.

Un Reference type invece, sono variabili che sono tipi di classe, tipi di interfacce o tipi di array. Una "reference" fa riferimento a un oggeto (un istanza di una classe). A differenza dei tipi primitivi che mantengono i loro valori im memoria dove la variabile è allocata, le referenze non mantengono il valore dell'oggetto a cui si riferiscono. Una referenza "punta" ad un oggetto memorizzando l'indirizzo dove l'oggetto è collocato. Tutto questo può essere ricondotto al conetto di "puntatore". Tuttavia Java non permette al programmatore di accedere direttamente ad un indirizzo fisico di memoria. Quindi anche se le referenze sono simili ai puntatori, è possibile solo usare una referenza per accedere ad un campo o un metodo dell'oggetto a cui fa riferimento. Risulta impossibile quindi determinare il reale indirizzo di memoria della variabile referenziata.
Vediamo un esempio ora. Dichiariamo due referenze:

java.util.Date today;
String greeting;

La variabile today è una refernza di tipo Date e può puntare solo a un oggetto di tipo Date. La variabile greeting invece è una referenza che può puntare solo ad un oggetto di tipo String. Un valore può essere assegnato ad una referenza in due modi:
- Una referenza può essere assegnata ad una referenza dello stesso tipo
- Una referenza può essere assegnata ad un nuovo oggetto usando la parola chiave "new"

Ad esempio assegnamo le due precedenti referenze a due nuovi oggetti:

today = new java.util.Date();
greeting = “How are you?”;

Ecco come queste due referenze sono rappresentate in memoria:

Sviluppo "guidato": il Test Driven Development

Il test driven development (TDD) è una pratica agile che richiede la creazione di test prima della scrittura del codice sorgente stesso da testare. In realtà è una metodologia utilizzata non per testare il codice, bensì per individuare con precisione le specifiche del software stesso. Ma come avviene questa tipologia di sviluppo? Come mostrato nella figura 1 la prima cosa da fare è quella di creare un test. Il secondo passo consiste nell'eseguire il test. Ovviamente non essendo ancora stato scritto codice per quel test, l'esecuzione del test comporta un fallimento. Occorre quindi apportare delle modifiche al codice in modo che il test sia superato e una volta che ciò avviene si continua con lo sviluppo.

Figura 1. Diagramma sviluppo TDD

Vediamo ora un esempio semplice di codice:

-          Aggiungiamo il test

public void NumberToEnglishShouldReturnOne()

{

  string actual = English.NumberToEnglish(1);

  Assert.AreEqual("one", actual, "Expected the result to be \"one\"");

}

-          Eseguiamo il test. Il test fallisce in quanto il codice non è stato ancora implementato

"NumbersInWords.Test.EnglishTest.NumberToEnglishShouldReturnOne :

    System.Exception :

The method or operation is not implemented.".

-         Scriviamo il codice in modo che il test sia superato

public static string NumberToEnglish(int number)

{

  return "one";

}

-          Eseguiamo di nuovo il test

-          Una volta che il test è passato il prossimo passo è iniziare di nuovo il processo (code refactoring)

Ad esempio il nuovo test sarà:

public void NumberToEnglishShouldReturnTwo()

{

  string actual = English.NumberToEnglish(2);

  Assert.AreEqual("two", actual, "Expected the result to be \"two\"");

}

Quindi modifichiamo il codice in modo che il test sia passato:

public static string NumberToEnglish(int number)

{

  if (number == 1)

    return "one";

  else

    return "two";

}

Ma quali sono i vantaggi di questa metodologia? Il codice. può essere testato singolarmente, sono individuate con precisione le specifiche del codice e sicuramente permette di individuare con facilità lo stato di avanzamento del progetto. Per ulteriori informazioni sul TDD date un'occhiata a questa pagina.

Android e i grafici: GraphView

Mi è capitato l'altro giorno, lavorando a un progetto personale, di dover mostrare dei grafici su alcuni dati memorizzati in un database sqlite. Android non offre nativamente la possibilità di usare i grafici ma esistono diverse librerie Java utilizzabili in Android. Molto interessante ho trovato la libreria GraphView di Jonas Gehring, facile da usare e abbastanza funzionale. Permette la creazione di grafici semplici come line chart e bar chart ma anche qualcosa di complesso come le serie multiple.
Vediamo ora un pezzo di codice che utilizza questa libreria.

Codice Java:


GraphViewData[] data = 
        new GraphViewData[data_from_db.size()];
       double v=0;
       for (int i=0; i<data_from_db.size(); i++) {
data[i] = new GraphViewData(i, data_from_db.get(i));
       }

GraphViewSeries exampleSeries= new GraphViewSeries("Sinus curve", Color.rgb(200, 50, 00), data);

GraphView graphView = new LineGraphView(this, "GraphViewDemo");

graphView.addSeries(exampleSeries); // data

graphView.setScrollable(true);

graphView.setHorizontalLabels(regioni);

graphView.setScalable(true);  

LinearLayout layout = (LinearLayout) findViewById(R.id.graph1);

layout.addView(graphView);

File Xml: 

<?xml version="1.0" encoding="utf-8"?>

<ScrollView android:id="@+id/ScrollView02" 

            android:layout_width="wrap_content" 

            android:layout_height="wrap_content" 

              xmlns:android="http://schemas.android.com/apk/res/android">

<HorizontalScrollView 

android:layout_width="fill_parent"

android:layout_height="fill_parent">

<LinearLayout

android:orientation="vertical"

android:layout_width="fill_parent"

android:layout_height="fill_parent">

<LinearLayout 

xmlns:android="http://schemas.android.com/apk/res/android"

android:layout_width="2000dip"

android:layout_height="500dip"

android:id="@+id/graph1" />

<TextView  

   android:id="@+id/legend"

   android:layout_width="wrap_content" 

   android:layout_height="wrap_content" 

android:textColor="#ffffff"

android:textSize="17sp" 

    />

  </LinearLayout>

    </HorizontalScrollView>

</ScrollView>

Il codice crea un serie a partire dal vettore data_from_db contenente i dati che vogliamo mostrare nel nostro grafico. Successivamente crea un oggetto di tipo GraphView che rappresenterà il nostro grafico e assegna a tale oggetto la serie creata in precedenza. Infine aggiunge il grafico al LinearLayout definito nel file xml.
Questo è il risultato ottenuto.

Una libreria facile da usare che offre diverse opzioni per rendere più gradevoli ed espliciti i propri grafici su Android. Per maggiori  informazioni consultare il blog ufficiale della libreria.

Il plurale di Http? Https!

Ecco un'altra classica domanda che ti capita, cosi per caso, ad un colloquio di lavoro. Che differenza c'è tra http e https? Diamo per scontato che sappiamo di cosa parliamo (protocolli) e che già siamo al corrente dell'esistenza del protocollo http. Che differenza c'è con il protocollo Https? la differenza la fa la S finale che sta per "secure". Si, il protocollo https è un'evoluzione di Http per renderlo più sicuro. In particolare è una combinazione del protocollo Http e il protocollo SSL/TLS. Il problema principale del protocollo Http è la possibilità di subire attacchi del tipo Man in the middle (un tipo di attacco dove l'attaccante è in grado di intercettare le comunicazioni tra i due partecipanti).

Https agisce sempre al livello più alto del modello ISO/OSI. Tutti i dati sono criptati compresi gli header. Un webserver per accettare connessioni di tipo Https deve creare un certificato digitale una sorta di carta di identità che associa l'identità di una persona ad una chiave pubblica. Una volta che il sito web ha fornito questo certificato che prova la sua bontà, il protocollo SSL/TLS è più che sufficiente a criptare il canale di comunicazione tra utente e sito web. I certificati sono approvati da specifiche certificate authorities (ad esempio VeriSign/Microsoft/etc.).

Riflettiamo con la Java Reflection

L'idea di questo post nasce da un test preselezione che ho fatto per un'azienda inglese. Dato un pezzo di codice veniva chiesto quale caratteristica del linguaggio Java era utilizzata. Si trattava della reflection.

La reflection è quella caratteristica del linguaggio Java che permette ad un programma  in esecuzione di accedere a proprietà interne del programma stesso. Tutto ciò ovviamente in contro tendenza con il paradigma orientato agli oggetti. Ad esempio con questa caratteristica è possibile per un classe Java ottenere e accedere al nome di tutti i suoi metodi e attributi ed eventualmente mostrarli.

Perché la reflection?

La violazione del principio di incapsulamento dei linguaggi object oriented può essere pericoloso ma se trattato con le giuste accortezze diventa uno strumento potentissimo. In particolare può essere utile nei framework e in casi in cui si necessità di un forte riutilizzo di codice. Consideriamo ora un esempio di codice Java (fonte sito ufficiale della Oracle):

   import java.lang.reflect.*;
 
   public class DumpMethods {
      public static void main(String args[])
      {
         try {
            Class c = Class.forName(args[0]);
            Method m[] = c.getDeclaredMethods();
            for (int i = 0; i < m.length; i++)
            System.out.println(m[i].toString());
         }
         catch (Throwable e) {
            System.err.println(e);
         }
      }
   }

Per usare la reflection occore effettuare l'import del package java.lang.reflect.Ora richiamando la classe DumpMethods e passando come input la stringa "java.util.Stack" l'output che otteniamo è il seguente:

 public java.lang.Object java.util.Stack.push(
    java.lang.Object)
   public synchronized 
     java.lang.Object java.util.Stack.pop()
   public synchronized
      java.lang.Object java.util.Stack.peek()
   public boolean java.util.Stack.empty()
   public synchronized 
     int java.util.Stack.search(java.lang.Object)

otteniamo quindi l'elenco dei metodi della classe Stack compreso di parametri e il tipo restituito da ogni metodo.

Un ottimo esempio di come sia utile la reflection è nella conversioni di documenti XML in oggetti Java (più facilmente manipolabili all'interno di un applicazione scritta in linguaggio Java). Trovate un ottimo esempio di codice qui.

Infine per una illustrazione completa dei diversi usi della reflection date anche un'occhiata qui.