Tutorial y ejemplos de Android Runnable
En esta clase vemos la interfaz Runnable y vemos sus ejemplos de uso.
¿Qué es un Runnable?
En java la interfaz Runnable es básicamente una abstracción para un comando ejecutable.
Hemos hablado de la clase Thread como una construcción de concurrencia de bajo nivel para java y android.
Bueno, otro bloque de construcción es el Runnable, una interfaz que proviene de la API de Java, y que pretende especificar y encapsular el código que está destinado a ser ejecutado por una instancia de Java thread o cualquier otra clase que maneje este Runnable.
Es una interfaz y está definida en el paquete java.lang y tiene un método abstracto llamado run() que debemos implementar.
package java.lang;
public interface Runnable{
public abstract void run();
}
Uso
La interfaz Runnable se utiliza mucho para ejecutar código en Threads.
La interfaz Runnable tiene un método abstracto llamado run():
public abstract void run ()Normalmente implementas ese método siempre que tu clase implemente la interfaz Runnable.
El método será llamado para comenzar a ejecutar la parte activa del código de la clase.
Digamos que queremos usar Runnable como nuestro mecanismo de enhebrado. Pues bien, primero implementa la interfaz. Luego, proporciona la implementación del método run():
public class MyRunnable implements Runnable {
public void run(){
Log.d("Generic","Running in the Thread " +
Thread.currentThread().getId());
}
}Con esto, nuestra subclase Runnable puede ahora ser pasada a Thread y se ejecuta independientemente en la línea de ejecución concurrente:
Thread thread = new Thread(new MyRunnable());
thread.start();En el siguiente código, básicamente hemos creado la subclase Runnable para que
implemente el método run() y pueda ser pasada y ejecutada por un hilo:
Interfaz Runnable Subclases indirectas
Runnable` tiene muchas subclases, por lo que sólo enumeramos algunas de las más utilizadas:
| No. | Clase Descripción
| La clase Thread hace uso del método abstracto run() de Runnable llamando al método concreto run() de Thread. Este método run() llama al método abstracto run() del Runnable internamente. |
| 2. TimerTask Una clase abstracta utilizada para describir una tarea que debe ejecutarse en un momento determinado, tal vez una vez, tal vez de forma recurrente. |
| 3. | Esta clase implementa la interfaz RunnableFuture, que implementa la interfaz Runnable. |
Veamos ahora algunos ejemplos:
Ejemplo de Android Runnable paso a paso
Este es un ejemplo de Android. Android obviamente utiliza Java y la interfaz Runnable ha existido desde el nivel 1 de la API.
Podemos utilizar un Runnable con un Service de la siguiente manera:
public class MyService extends Service implements Runnable{}Esto nos obligará a implementar el método abstracto run() dentro de esa clase:
@Override
public void run() {
}Y dado que se trata de un Service también tendremos que sobreescribir otro método abstracto para Service llamado onBind()
@Override
public IBinder onBind(Intent intent) {
return null;
}El Service es un componente de Android que tiene callbacks del ciclo de vida. Uno de ellos es onCreate(), un método que se activa cada vez que se crea un Service.
Así que para nosotros cada vez que esto ocurra queremos crear un thread e iniciarlo:
@Override
public void onCreate() {
super.onCreate();
Thread myThead=new Thread(this);
myThead.start();
}Entonces digamos que queremos registrar algunos mensajes cada 1 segundo, añadimos el siguiente código dentro del método run():
while (true)
{
try{
Log.i(MY_TAG,"Distance in Light Years : "+spaceship_distance);
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}Luego como variables de instancia, añade lo siguiente encima de tu método onCreate():
public static String MY_TAG="MY_SERVICE";
private int spaceship_distance=0;Bueno, este es un ejemplo del uso de Runnable con Android. Si estás interesado en que el Service se ejecute realmente: entonces haz lo siguiente:
- Registra el
Serviceen el Manifiesto:
```java
```
Asegúrate de especificar el nombre de tu <code>Servicio</code> en lugar de <code>MiServicio</code>.</code></pre>
<ol start="2">
<li>Inicia el <code>Service</code> en la <code>MainActivity</code>:</li>
</ol>
<!-- 12 -->
<pre><code>```java
Intent i=new Intent(this,MyService.class);
startService(i);
```Y eso es todo, un ejemplo de interfaz androide Runnable con servicios.
Ten en cuenta que a veces la gente utiliza Runnable de esta manera:
@Override
public void onCreate() {
super.onCreate();
new Thread(new Runnable() {
@Override
public void run() {
ArrayList<Song> songs = scanSongs(ScanMusicService.this);
LogUtils.d(songs);
ToastUtils.showLongToast(songs.toString());
}
}).start();
}Ejemplos rápidos de Runnable
(a). Cómo realizar un HTTP GET con HttpURLConnection y Runnable.
HttpURLConnection es nuestra clase de red y nos permite realizar nuestra petición HTTP GET.
Por otro lado Runnable es nuestra interfaz que nos permitirá realizar nuestra petición HTTP GET en el hilo de fondo.
Así que empieza implementando la interfaz Runnable, lo que te obliga a anular el método run().
Es dentro de ese método run() donde realizamos nuestro HTTP GET :
public class UrlRequest implements Runnable {
......
@Override
public void run() {
try {
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
InputStream stream = connection.getInputStream();
int responseCode = connection.getResponseCode();
ByteArrayOutputStream responseBody = new ByteArrayOutputStream();
byte buffer[] = new byte[1024];
int bytesRead = 0;
while ((bytesRead = stream.read(buffer)) > 0) {
responseBody.write(buffer, 0, bytesRead);
}
listener.onReceivedBody(responseCode, responseBody.toByteArray());
}
catch (Exception e) {
listener.onError(e);
}
}
}Aquí está la clase completa:
import android.support.annotation.NonNull;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;
public class UrlRequest implements Runnable {
public interface Listener {
void onReceivedBody(int responseCode, byte body[]);
void onError(Exception e);
}
public interface RequestFactory {
@NonNull
UrlRequest makeRequest(URL url, Listener listener);
}
private static RequestFactory factory = new RequestFactory() {
@NonNull
@Override
public UrlRequest makeRequest(URL url, Listener listener) {
return new UrlRequest(url, listener);
}
};
private URL url;
private Listener listener;
public static UrlRequest makeRequest(URL url, Listener listener) {
return factory.makeRequest(url, listener);
}
public static void setFactory(RequestFactory newFactory) {
factory = newFactory;
}
public UrlRequest(URL url, Listener listener) {
this.url = url;
this.listener = listener;
}
@Override
public void run() {
try {
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
InputStream stream = connection.getInputStream();
int responseCode = connection.getResponseCode();
ByteArrayOutputStream responseBody = new ByteArrayOutputStream();
byte buffer[] = new byte[1024];
int bytesRead = 0;
while ((bytesRead = stream.read(buffer)) > 0) {
responseBody.write(buffer, 0, bytesRead);
}
listener.onReceivedBody(responseCode, responseBody.toByteArray());
}
catch (Exception e) {
listener.onError(e);
}
}
}