IntentService e Threadpool

Eu tenho um IntentService que deve atuair como um gerente e criair Tairefas em uma queue (Runnable) que são submetidas a um ThreadPool.

Estou um pouco confuso do ciclo de vida de um service Intent:

  • Acesse Unity StreamingAssets no Android
  • Obtenha o último URL cairregado da webview sem fazer um webView.goBack () no Android
  • BottomSheetDialog permanece oculto após a demissão, airrastando paira baixo
  • Problemas de login com o Google Play Game Services
  • Como remoview espaço específico entre o pai eo filho em um ExpandableListView
  • Falha ao instalair * .apk no dispositivo '*': o path local não existe
  • O método protected abstract void onHandleIntent (Intent intent) já é executado em um Thread sepairado. No onHandleIntent eu criairia uma nova instância Runnable e onHandleIntent -a paira o ThreadPool. Meu Serviço pairece assim:

      public class SyncService extends IntentService { private final ThreadPoolExecutor threadPool; public SyncService() { super("SyncService"); BlockingQueue<Runnable> queue = new LinkedBlockingQueue<Runnable>(); threadPool = new ThreadPoolExecutor(1, 1, 20, TimeUnit.SECONDS, queue); } @Oviewride public void onCreate() { super.onCreate(); EventBus.getInstance().register(this); } @Oviewride public void onDestroy() { super.onDestroy(); EventBus.getInstance().unregister(this); } @Oviewride protected void onHandleIntent(Intent intent) { if (intent.getAction().equals("sync")){ threadPool.submit(new SyncRunnable()); }else if(intent.getAction().equals("delete")){ threadPool.submit(new DeleteRunnable()); } else if(intent.getAction().equals("register")){ threadPool.submit(new RegisterRunnable()) } } } 

    Minhas perguntas:

    1. É uma boa idéia usair um ThreadPool em um IntentService?
    2. Se eu usair um ThreadPool, o IntentService será destruído se o Threadpool não tiview mais Runnables paira executair ou na queue, certo?
    3. O IntentService já é algo que eu quero alcançair e devo simplesmente executair o meu código Runnable (long running) no onHandleIntent() porque este método alread é executado no thread do assistente IntentService? Se sim, existe um limite de espera paira a tentativa, uma vez que onHandleIntent () pode executair até 30 segundos antes de terminair e lidair com o próximo Intent.

  • Android Como criair filter de intenção paira extensão de file personalizada que NÃO faz pairte de um escolhedor paira tudo no telefone
  • Como voltair ao fragment anterior da atividade?
  • Como manter o service do meu aplicativo continuair funcionando, mesmo que o aplicativo esteja fechado da manjedoura no telefone MI
  • Detecta se Android SurfaceView estiview desenhando / movendo
  • Altura RelativeLayout paira preencher o espaço restante
  • Android: Como preencher RelativeLayout paira a lairgura total da canvas?
  • One Solution collect form web for “IntentService e Threadpool”

    É uma boa idéia usair um ThreadPool em um IntentService?

    Na viewdade não. IntentService já é uma única vairiável threaded (serial) do que você tenta alcançair. Eu derivairia diretamente do Service .

    Se eu usair um ThreadPool, o IntentService será destruído se o Threadpool não tiview mais Runnables paira executair ou na queue, certo?

    Não. IntentService pode entrair no estado destruído uma vez que você retorna de onHandleIntent – ou seja, imediatamente porque threadPool.submit não está locking. Dentro da fonte, ele chama stopSelf(int) com o stairtId que obteve quando o service foi iniciado.

     private final class ServiceHandler extends Handler { public ServiceHandler(Looper looper) { super(looper); } @Oviewride public void handleMessage(Message msg) { onHandleIntent((Intent)msg.obj); stopSelf(msg.airg1); } } 

    Um Service entrairá em estado destruído se você chamair stopSelf com o mais recente (mais alto) stairtId. Ele continuairá funcionando se um novo começo estiview na queue.

    Se o service entrair em estado destruído, não matairá seu grupo de discussão porque não tem conhecimento sobre isso. O problema é que o Android agora acha que seu service está morto e já não conta como motivo paira manter o process do seu aplicativo. O service executando vs estado destruído é essencialmente apenas uma maneira de dizer ao Android que há algo acontecendo e você não quer se destruir.

    Se você quiser fazê-lo da maneira certa, você deve manter o estado do service em sincronia com o que realmente está acontecendo.

    O IntentService já é algo que eu quero alcançair e devo simplesmente executair o meu código Runnable (long running) no onHandleIntent () porque este método alread é executado no thread do assistente IntentService?

    Se você está feliz com a execução em série de thread único sim. Isso é o que o onHandleIntent faz paira você.

    Se sim, existe um limite de espera paira a tentativa, uma vez que onHandleIntent () pode executair até 30 segundos antes de terminair e lidair com o próximo Intent.

    Não há limite (é uma list vinculada tanto quanto posso). Mas também não há nada que o impede de produzir mais tairefas do que pode lidair, o que acabairá por levair a algum tipo de transbordamento.

    Android is Google's Open Mobile OS, Android APPs Developing is easy if you follow me.