如何在Android的后台线程上运行代码？

我希望一些代码在后台连续运行。我不想在服务中这样做。还有其他办法吗？

我曾尝试Thread在我的班级中调用该类，Activity但我Activity仍然在后台停留一段时间，然后停止。该Thread班也停止工作。

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

    }

如果你需要：

1. 在后台线程上执行代码

2. 执行不触摸/不更新用户界面的代码

3. 执行（简短）代码，最多需要几秒钟才能完成

然后使用以下使用AsyncTask的干净高效的模式：

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

记住运行后台，连续运行是两个不同的任务。

对于长期的后台进程，线程并不是Android的最佳选择。但是，这是代码，需要您自担风险...

记住Service或Thread将在后台运行，但是我们的任务需要触发（一次又一次地调用）来获取更新，即，一旦任务完成，我们就需要调用该函数以进行下一次更新。

计时器（定期触发），警报（时基触发），广播（事件基触发），递归将唤醒我们的功能。

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();
}

使用服务： 如果启动服务，它将启动，它将执行任务，并终止自身。任务执行后。终止也可能是由异常引起的，或者用户从设置中手动将其终止。START_STICKY（粘性服务）是android给出的选项，如果服务终止，服务将自行重启。

还记得多处理和多线程之间的问题区别吗？ 服务是一个后台进程（就像没有UI的活动一样），与在活动中启动线程以避免在主线程（活动线程）上加载的方式相同，与在服务上启动线程（或异步任务）所需的方式相同避免增加服务负荷。

在单个语句中，如果要运行后台继续任务，则需要启动StickyService并基于事件在服务中运行线程

我希望一些代码在后台连续运行。我不想在服务中这样做。还有其他办法吗？

您正在寻找的最可能的机械是AsyncTask。它直接指定用于在后台线程上执行后台进程。它的主要好处还在于，它提供了一些在Main（UI）线程上运行的方法，如果您想让用户了解任务的某些进展或使用从后台进程检索的数据来更新UI，则可以更新您的UI。

如果您不知道如何开始，这里是个不错的教程：

• 了解AsyncTask –一劳永逸

注意：也有可能IntentService与之配合使用ResultReceiver。

简单的三线

@awardak在布兰登·鲁德（Brandon Rude）的答案中以评论的方式找到了一种简单的方法：

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

我不确定这是否或如何比使用更好，AsyncTask.execute但似乎对我们有用。关于差异的任何评论将不胜感激。

谢谢，@ awardak！

Robospice是AsyncTask的替代方法。https://github.com/octo-online/robospice。

robospice的某些功能。

1.异步执行（在后台AndroidService中）网络请求（例如：使用Spring Android的REST请求）。准备好结果后，在UI线程上通知您的应用。

2.是强类型的！您使用POJO发出请求，并获得POJO作为请求结果。

3.不对用于请求的POJO或项目中使用的Activity类施加任何约束。

4.缓存结果（在Json中同时包含Jackson和Gson，或者Xml，或者纯文本文件，或者二进制文件，甚至使用ORM Lite）。

5.当且仅当活动仍然存在时，才将网络请求的结果通知您的活动（或任何其他上下文）

6，完全没有内存泄漏，就像Android Loaders一样，与Android AsyncTasks在其UI线程上通知您的活动无关。

7.使用简单但健壮的异常处理模型。

样品开始。https://github.com/octo-online/RoboSpice-samples。

在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;
    }
}

如果您需要使用不同的代码方便地运行线程，请参见以下示例：

听众：

public interface ESLThreadListener {

    public List onBackground();

    public void onPostExecute(List list);

}

螺纹类

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;
    }
}

运行不同的代码：

  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();