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. UIに触れたり更新したりしないコードを実行する

3. 完了するまでに最大で数秒かかる（短い）コードを実行する

次に、AsyncTaskを使用する次のクリーンで効率的なパターンを使用します。

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

ランニングバックグラウンドを忘れないでください。継続的なランニングは2つの異なるタスクです。

長期的なバックグラウンドプロセスの場合、Androidではスレッドは最適ではありません。しかし、ここにコードがあり、あなた自身の責任でそれをしてください...

サービスまたはスレッドはバックグラウンドで実行されますが、更新を取得するにはタスクをトリガー（何度も呼び出す）する必要があります。つまり、タスクが完了したら、次の更新のために関数を呼び出す必要があります。

タイマー（定期的なトリガー）、アラーム（タイムベーストリガー）、ブロードキャスト（イベントベーストリガー）、再帰によって機能が呼び起こされます。

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のない​​アクティビティと同様）。メインスレッド（アクティビティスレッド）の負荷を回避するためにアクティビティでスレッドを起動する方法と同じです。サービスでスレッド（または非同期タスク）を起動する必要があるのと同じ方法です。サービスへの負荷を避けるため。

1つのステートメントで、バックグラウンド継続タスクの実行が必要な場合は、StickyServiceを起動し、イベントベースのサービスでスレッドを実行する必要があります

一部のコードをバックグラウンドで継続的に実行してほしい。サービスでそれをしたくありません。他に可能な方法はありますか？

あなたが探している最も可能性の高いメカニズムはAsyncTaskです。バックグラウンドスレッドでバックグラウンドプロセスを実行するために直接指定されています。また、その主な利点は、Main（UI）スレッドで実行されるいくつかのメソッドを提供し、タスクの進行状況についてユーザーに通知したり、バックグラウンドプロセスから取得したデータでUIを更新したりする場合にUIを更新できるようにすることです。

ここから始める方法がわからない場合は、素晴らしいチュートリアルです。

• AsyncTaskの理解–いつまでも

注：また、使用する可能性があるIntentServiceとResultReceiver同様にその作品は。

シンプルな3ライナー

私がすることによって、コメントとして見つけたこれを行うための簡単な方法@awardakでブランドンルードの答え：

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

これが使用するよりも良いかどうか、どのように良いかはわかりませんが、うまくAsyncTask.executeいくようです。違いについてのコメントはいただければ幸いです。

ありがとう、@ awardak！

AsyncTaskの代替はrobospiceです。https://github.com/octo-online/robospice。

ロボスパイスのいくつかの機能。

1.非同期で（バックグラウンドAndroidServiceで）ネットワークリクエストを実行します（例：Spring Androidを使用したRESTリクエスト）。結果が準備できたら、UIスレッドでアプリに通知します。

2.強く型付けされています！POJOを使用してリクエストを作成し、リクエスト結果としてPOJOを取得します。

3.リクエストに使用されるPOJOにも、プロジェクトで使用するアクティビティクラスにも制約を適用しません。

4.結果をキャッシュします（JSONでJacksonとGsonの両方、またはXml、またはフラットテキストファイル、またはバイナリファイル、さらにORM Liteを使用）。

5.それらがまだ生きている場合にのみ、ネットワーク要求の結果をアクティビティ（またはその他のコンテキスト）に通知します

Androidローダーとは異なり、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にあるrobospiceのサンプル。

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