Usare i thread in Java con Executor Framework

In Java, per creare un task, generalmente implementiamo l'interfacca Runnable o estendiamo la classe Thread.

Con le ultime versioni (non so precisamente da quale) è possibile agire anche in altra maniera, ovvero usando l'Executor Framework.

La classe Executors (da non confondere con l'interfaccia Executor) ci mette a disposizione tre metodi:

• newCachedThreadPool(): crea un nuovo thread quando serve, ed usa la cache per velocizzarne l'eventuale riuso
• newFixedThreadPool(int nThreads): il numero massimo di thread viene impostato come parametro
• newSingleThreadExecutor(): un unico thread che esegue tutti i task; se "muore" viene ricreato

Andiamo a vedere semplice esempio.

Catturare l'output di un comando in Java

Quando lanciamo un comando da un nostro programma in Java (Swing), di default non ne vediamo l'output.

E il motivo è che, generalmente, viene mandato sullo standard output, che non è la interfaccia scritta in Java.

In molti casi, però, potrebbe essere importante catturare l'output, soprattutto per vedere a che punto siamo con la sua esecuzione.

Oggi vediamo proprio questo: come visualizzare l'output di un comando su una JTextArea.

Il programma che lanceremo sarà youtube-dl, programma da riga di comando per scaricare la musica in formato MP3 da Youtube.

Aggiornare la gui in Qt da un altro thread

Supponiamo di voler eseguire un operazione in un thread secondario, e di voler aggiornare la nostra gui man mano che l'operazione va avanti: come possiamo fare questa cosa in Qt?

Molto semplicemente usando il metodo connect, i SIGNAL e gli SLOT.

Direi di cominciare dal nostro lavoro in background:

// workerthread.h
#ifndef WORKTHREAD_H
#define WORKTHREAD_H

#include <QMutex>
#include <QThread>

class WorkerThread : public QThread
{
    Q_OBJECT
public:
    explicit WorkerThread(QObject *parent = 0, bool b = false);
    void run();
    bool stop;

signals:
    void valueChanged(QString text);
    void finished();
};

#endif // WORKTHREAD_H

Recuperare un elemento random da una lista in Java

Oggi vediamo tre modi per recuperare un elemento random da una lista.

Useremo tre oggetti distinti:

• ThreadLocalRandom
• Random
• Math

Il primo è inoltre suggerito nel caso di utilizzo del multi-threading.

Partiremo sempre dallo stessa ArrayList.

Invio di file tramite socket in Java (2nd edition)

In questo articolo avevo già parlato di come trasferire file tramite socket in Java.

Il problema però è che funziona solo se sia il client che il server stanno sulla stessa macchina.

Questo perchè ho fatto uso di oggetti File che sono solo una rappresentazione di un file o directory sul pc, ma che non sanno nulla circa il lror contenuto.

Se invece server e client devono stare su macchine diverse bisogna cambiare un pò la logica.

In sostanza il client deve leggere e inviare il file byte per byte; il server legge tutti i byte e li salva sul pc.

Non si può quindi usare File.

Questo è il client:

import java.io.FileInputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;

public class Client {

private final String HOST = "host";
private final int PORT = 9977;

public static void main(String[] args) {
Client c = new Client();
c.sendFile();
}

private void sendFile() {
try {
Socket socket = new Socket(HOST, PORT);
FileInputStream fis = new FileInputStream("path/to/file");
OutputStream out = socket.getOutputStream();
byte[] buf = new byte[1024];
int read;
while ((read = fis.read(buf)) != -1) {
out.write(buf, 0, read);
}
fis.close();
out.close();
socket.close();
} catch (UnknownHostException ex) {
System.out.println(ex.getMessage());
} catch (IOException ex) {
System.out.println(ex.getMessage());
}
}
}

In pratica usiamo FileInputStream per leggere il contenuto del file, e OutputStream per inviare i byte.