¿Cómo puedo ejecutar código en un hilo de fondo en Android?

Quiero que algún código se ejecute en segundo plano continuamente. No quiero hacerlo en un servicio. ¿Hay alguna otra forma posible?

He intentado llamar a la Threadclase en mi Activitypero mis Activityrestos permanecen en segundo plano por algún tiempo y luego se detiene. La Threadclase también deja de funcionar.

class testThread implements Runnable {
        @Override
        public void run() {
            File file = new File( Environment.getExternalStorageDirectory(), "/BPCLTracker/gpsdata.txt" );
            int i = 0;

            RandomAccessFile in = null;

            try {
                in = new RandomAccessFile( file, "rw" );
            } catch (FileNotFoundException e) {
// TODO Auto-generated catch block
                e.printStackTrace();
            } catch (IOException e) {
// TODO Auto-generated catch block
                e.printStackTrace();
            }
//String line =null;
            while ( true ) {
                HttpEntity entity = null;
                try {
                    if ( isInternetOn() ) {
                        while ( ( line = in.readLine() ) != null ) {

                            HttpClient client = new DefaultHttpClient();
                            String url = "some url";
                            HttpPost request = new HttpPost( url );
                            StringEntity se = new StringEntity( line );
                            se.setContentEncoding( "UTF-8" );
                            se.setContentEncoding( new BasicHeader( HTTP.CONTENT_TYPE, "application/json" ) );
                            entity = se;
                            request.setEntity( entity );
                            HttpResponse response = client.execute( request );
                            entity = response.getEntity();
                            i++;
                        }
                        if ( ( line = in.readLine() ) == null && entity != null ) {
                            file.delete();
                            testThread t = new testThread();
                            Thread t1 = new Thread( t );
                            t1.start();
                        }


                    } else {
                        Thread.sleep( 60000 );
                    } // end of else

                } catch (NullPointerException e1) {
                    e1.printStackTrace();
                } catch (InterruptedException e2) {
                    e2.printStackTrace();
                } catch (IOException e1) {
// TODO Auto-generated catch block
                    e1.printStackTrace();
                }
            }// end of while
        }// end of run

    }

Si lo necesitas:

1. ejecutar código en un hilo de fondo

2. ejecutar código que NO toca / actualiza la IU

3. ejecutar código (corto) que tardará como máximo unos segundos en completarse

ENTONCES use el siguiente patrón limpio y eficiente que usa AsyncTask:

AsyncTask.execute(new Runnable() {
   @Override
   public void run() {
      //TODO your background code
   }
});

Recuerde Ejecutar en segundo plano, Ejecutar continuamente son dos tareas diferentes.

Para procesos en segundo plano a largo plazo, los hilos no son óptimos con Android. Sin embargo, aquí está el código y hágalo bajo su propio riesgo ...

Recuerde que Service o Thread se ejecutará en segundo plano, pero nuestra tarea debe activarse (llamar una y otra vez) para obtener actualizaciones, es decir, una vez que se complete la tarea, debemos recuperar la función para la próxima actualización.

Temporizador (activador periódico), Alarma (activador de base de tiempo), Difusión (Activador de base de eventos), la recursividad despertará nuestras funciones.

public static boolean isRecursionEnable = true;

void runInBackground() {
    if (!isRecursionEnable)
        // Handle not to start multiple parallel threads
        return;

    // isRecursionEnable = false; when u want to stop
    // on exception on thread make it true again  
    new Thread(new Runnable() {
        @Override
        public void run() {
            // DO your work here
            // get the data
            if (activity_is_not_in_background) {
                runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        // update UI
                        runInBackground();
                    }
                });
            } else {
                runInBackground();
            }
        }
    }).start();
}

Uso del servicio: si inicia un servicio, se iniciará, ejecutará la tarea y finalizará. después de la ejecución de la tarea. terminado también puede ser causado por una excepción, o el usuario lo eliminó manualmente desde la configuración. START_STICKY (Sticky Service) es la opción dada por Android de que el servicio se reiniciará solo si el servicio finaliza.

¿Recuerdas la diferencia de preguntas entre multiprocesamiento y multiproceso? El servicio es un proceso en segundo plano (al igual que la actividad sin interfaz de usuario), de la misma manera que inicia el hilo en la actividad para evitar la carga en el hilo principal (hilo de actividad), de la misma manera que necesita lanzar hilos (o tareas asíncronas) en el servicio para evitar la carga en el servicio.

En una sola declaración, si desea ejecutar una tarea continua en segundo plano, debe iniciar un StickyService y ejecutar el hilo en el servicio en la base de eventos

Quiero que algún código se ejecute en segundo plano continuamente. No quiero hacerlo en un servicio. ¿Hay alguna otra forma posible?

El mecanismo más probable que está buscando es AsyncTask. Se designa directamente para realizar un proceso en segundo plano en el subproceso en segundo plano. Además, su principal beneficio es que ofrece algunos métodos que se ejecutan en el subproceso principal (UI) y hacen posible actualizar su interfaz de usuario si desea anunciar al usuario sobre algún progreso en la tarea o actualizar la interfaz de usuario con los datos recuperados del proceso en segundo plano.

Si no sabes cómo comenzar aquí, es un buen tutorial:

• Comprender AsyncTask: una vez y para siempre

Nota: También existe la posibilidad de usar IntentServicecon ResultReceivereso funciona también.

Simple 3-Liner

Una forma simple de hacerlo que encontré como un comentario de @awardak en la respuesta de Brandon Rude :

new Thread( new Runnable() { @Override public void run() { 
  // Run whatever background code you want here.
} } ).start();

No estoy seguro de si, o cómo, esto es mejor que usarlo, AsyncTask.executepero parece funcionar para nosotros. Cualquier comentario sobre la diferencia sería apreciado.

Gracias, @awardak !

Una alternativa a AsyncTask es robospice. https://github.com/octo-online/robospice .

Algunas de las características de robospice.

1.ejecuta asincrónicamente (en un servicio Android de fondo) solicitudes de red (por ejemplo: solicitudes REST usando Spring Android). Notifique su aplicación, en el hilo de la interfaz de usuario, cuando el resultado esté listo.

2.es fuertemente tipado! Realiza sus solicitudes utilizando POJO y obtiene POJO como resultados de la solicitud.

3. no imponga restricciones ni a los POJO utilizados para las solicitudes ni a las clases de Actividad que utilice en sus proyectos.

4.caché resultados (en Json con Jackson y Gson, o Xml, o archivos de texto plano, o archivos binarios, incluso usando ORM Lite).

5. notifica sus actividades (o cualquier otro contexto) del resultado de la solicitud de red si y solo si todavía están vivos

6.no hay pérdida de memoria, como Android Loaders, a diferencia de Android AsyncTasks notifica tus actividades en su UI Thread.

7.utiliza un modelo de manejo de excepciones simple pero robusto.

Muestras para empezar. https://github.com/octo-online/RoboSpice-samples .

Una muestra de robospice en https://play.google.com/store/apps/details?id=com.octo.android.robospice.motivations&feature=search_result .

class Background implements Runnable {
    private CountDownLatch latch = new CountDownLatch(1);
    private  Handler handler;

    Background() {
        Thread thread = new Thread(this);
        thread.start();
        try {
            latch.await();
        } catch (InterruptedException e) {
           /// e.printStackTrace();
        }
    }

    @Override
    public void run() {
        Looper.prepare();
        handler = new Handler();
        latch.countDown();
        Looper.loop();
    }

    public Handler getHandler() {
        return handler;
    }
}

Si necesita ejecutar un hilo predioticamente con diferentes códigos, este es un ejemplo:

Oyente:

public interface ESLThreadListener {

    public List onBackground();

    public void onPostExecute(List list);

}

Clase de hilo

public class ESLThread extends AsyncTask<Void, Void, List> {


    private ESLThreadListener mListener;

    public ESLThread() {

        if(mListener != null){

            mListener.onBackground();
        }
    }

    @Override
    protected List doInBackground(Void... params) {

        if(mListener != null){

            List list = mListener.onBackground();

            return list;
        }

        return null;
    }

    @Override
    protected void onPostExecute(List t) {
        if(mListener != null){

            if ( t != null) {
                mListener.onPostExecute(t);
            }
        }

    }


    public void setListener(ESLThreadListener mListener){

        this.mListener = mListener;
    }
}

Ejecuta diferentes códigos:

  ESLThread thread = new ESLThread();
                        thread.setListener(new ESLThreadListener() {
                            @Override
                            public List onBackground() {
                                List<EntityShoppingListItems>  data = RoomDB.getDatabase(context).sliDAO().getSL(fId);

                                return data;

                            }

                            @Override
                            public void onPostExecute(List t) {

                                List<EntityShoppingListItems> data = (List<EntityShoppingListItems>)t;
                                adapter.setList(data);
                            }
                        });

                        thread.execute();