Mantenha tudo organizado com as coleções
Salve e categorize o conteúdo com base nas suas preferências.
Figura 1. Uma caixa de diálogo de ANR mostrada ao usuário.
Este documento descreve como o sistema Android determina se um app deixou de
responder e oferece diretrizes para garantir que ele se mantenha responsivo.
Mesmo que o código seja bem escrito, é possível que o app ainda
fique lento, trave, congele por períodos significativos ou demore muito para processar
entradas. Se o app estiver em primeiro plano e não responder, uma
caixa de diálogo "O app não está respondendo" (ANR) vai aparecer, conforme mostrado na Figura 1. A caixa de diálogo ANR
permite que o usuário force o fechamento do app. Se o app não estiver em primeiro plano, ele será
parado silenciosamente. É fundamental projetar a capacidade de resposta no app para
minimizar as caixas de diálogo ANR.
Acionadores de ANR
Geralmente, o sistema mostra um ANR quando um app não pode responder à entrada do usuário na
linha de execução principal, também conhecida como linha de execução de interface, impedindo que o sistema
processe os eventos de entrada do usuário recebidos.
Por exemplo, um ANR pode ocorrer se um app realizar uma operação de E/S de bloqueio, como
acesso à rede, na linha de execução de interface. Outro exemplo é quando um app passa muito
tempo criando uma estrutura elaborada na memória ou calculando a próxima jogada
em um jogo na linha de execução de interface.
No Android, a capacidade de resposta do app é monitorada pelos serviços de sistema ActivityManager e
WindowManager. O Android mostra a caixa de diálogo ANR para um app
quando detecta uma das condições abaixo:
Nenhuma resposta a um evento de entrada (por exemplo, eventos de pressionamento de tecla ou toque na tela) em até cinco
segundos.
Confira abaixo dicas gerais para evitar ANRs. Para saber mais sobre como diagnosticar
e depurar diferentes tipos de ANR, consulte as outras páginas desta seção.
Mantenha a linha de execução principal sempre desbloqueada e use as linhas de execução de forma estratégica.
Não execute operações de bloqueio ou de longa duração na linha de execução principal do app.
Em vez disso, crie uma linha de execução de worker e faça a maior parte do trabalho nela.
Tente minimizar todas as contenções de bloqueio entre a linha de execução principal e outras
linhas de execução.
Minimize qualquer trabalho não relacionado à interface na linha de execução principal, por exemplo, ao processar
transmissões ou executar serviços. Todo método realizado na linha de execução de interface precisa
fazer o mínimo de trabalho possível nessa linha de execução. Em especial, as atividades precisam
fazer o mínimo possível para configurar os principais métodos do ciclo de vida, por exemplo,
onCreate() e onResume(). Consulte a Visão geral dos trabalhos em segundo plano para mais
informações sobre as soluções disponíveis para programar o trabalho em uma linha de execução
em segundo plano e se comunicar com a interface.
Tenha cuidado ao compartilhar pools de linhas de execução entre componentes. Não use as mesmas
linhas de execução para operações de bloqueio possivelmente longas e tarefas urgentes,
como recebimento de transmissão.
.
Agilize a inicialização do app. Minimize operações lentas ou de bloqueio no código de inicialização
do app, por exemplo, métodos executados durante a inicialização do Dagger.
O tempo de execução de BroadcastReceiver é limitado porque o objetivo dos broadcast receivers
é realizar pequenas quantidades de trabalho discretas em segundo plano, por exemplo,
salvar uma configuração ou registrar uma Notification de dois minutos. Assim como com outros
métodos chamados na linha de execução de interface, os apps precisam evitar operações
ou cálculos possivelmente longos em broadcast receivers. Em vez de realizar
tarefas de longa duração na linha de execução de interface, execute-as em segundo plano para execução
futura. Consulte Visão geral dos trabalhos em segundo plano para mais informações sobre possíveis
soluções.
Outro problema comum com objetos BroadcastReceiver ocorre quando eles são executados
com muita frequência. A execução frequente em segundo plano pode reduzir a quantidade de memória
disponível para outros apps. Para mais informações sobre como ativar e desativar
objetos BroadcastReceiver de forma eficiente, consulte Visão geral de transmissões.
Reforçar a capacidade de resposta
Geralmente, 100 a 200 ms é o limite além do qual os usuários percebem lentidão em
um app. Confira abaixo mais dicas de como fazer seu app parecer responsivo para os usuários.
Caso seu app esteja executando algo em segundo plano em resposta a uma entrada do usuário, use
uma ProgressBar para mostrar o progresso da execução na interface.
Para jogos especificamente, faça cálculos de movimentos em uma linha de execução de worker.
Caso seu app tenha uma fase de configuração inicial demorada, considere mostrar uma
tela de apresentação ou renderizar a visualização principal o mais rápido possível.
Indique que o carregamento está em andamento e preencha as informações de forma assíncrona.
Nos dois casos, recomendamos indicar de alguma forma que o progresso está sendo feito,
para que o usuário não perceba que o app está congelado.
Use ferramentas de análise de performance, por exemplo, o Perfetto e o CPU Profiler, para
determinar gargalos na capacidade de resposta do app.
O conteúdo e os exemplos de código nesta página estão sujeitos às licenças descritas na Licença de conteúdo. Java e OpenJDK são marcas registradas da Oracle e/ou suas afiliadas.
Última atualização 2025-07-27 UTC.
[[["Fácil de entender","easyToUnderstand","thumb-up"],["Meu problema foi resolvido","solvedMyProblem","thumb-up"],["Outro","otherUp","thumb-up"]],[["Não contém as informações de que eu preciso","missingTheInformationINeed","thumb-down"],["Muito complicado / etapas demais","tooComplicatedTooManySteps","thumb-down"],["Desatualizado","outOfDate","thumb-down"],["Problema na tradução","translationIssue","thumb-down"],["Problema com as amostras / o código","samplesCodeIssue","thumb-down"],["Outro","otherDown","thumb-down"]],["Última atualização 2025-07-27 UTC."],[],[],null,["# Keep your app responsive\n\n**Figure 1.** An ANR dialog displayed to the user.\n\nThis document describes how the Android system determines whether an app isn't\nresponding and shows how to keep your app responsive.\n\nNo matter how well-written your code is, it's possible for your app to still\nfeel sluggish, hang, freeze for significant periods, or take too long to process\ninput. If your app is in the foreground and is unresponsive, the user gets an\nApplication Not Responding (ANR) dialog, as shown in figure 1. The ANR dialog\nlets the user force quit the app. If the app isn't in the foreground, then it's\nsilently stopped. It's critical to design responsiveness into your app to\nminimize ANR dialogs.\n\nANR triggers\n------------\n\nGenerally, the system displays an ANR if an app can't respond to user input on\nthe main thread---also known as the UI thread---preventing the system from\nprocessing incoming user input events.\n\nFor example, an ANR can occur if an app performs a blocking I/O operation, such\nas network access, on the UI thread. Another example is when an app spends too\nmuch time building an elaborate in-memory structure or computing the next move\nin a game on the UI thread.\n\nIn Android, app responsiveness is monitored by the [`ActivityManager`](/reference/android/app/ActivityManager) and\n[`WindowManager`](/reference/android/view/WindowManager) system services. Android displays the ANR dialog for an app\nwhen it detects one of the following conditions:\n\n- No response to an input event---such as key press or screen tap events---within 5 seconds.\n- A [`BroadcastReceiver`](/reference/android/content/BroadcastReceiver) doesn't finish executing within 10 to 20 seconds, for foreground intents. For more information, see [Broadcast receiver timeout](/topic/performance/anrs/diagnose-and-fix-anrs#broadcast-receiver-anr).\n\nAvoid ANRs\n----------\n\nThe following are general tips to avoid ANRs. For more details about diagnosing\nand debugging different types of ANRs, see the other pages in this section.\n\n- Keep the main thread unblocked at all times, and use threads strategically.\n\n - Don't perform blocking or long-running operations on the app's main thread.\n Instead, create a worker thread and do most of the work there.\n\n - Try to minimize any lock contention between the main thread and other\n threads.\n\n - Minimize any non-UI related work on the main thread, such as when handling\n broadcasts or running services. Any method that runs in the UI thread must\n do as little work as possible on that thread. In particular, activities must\n do as little as possible to set up in key lifecycle methods, such as\n `onCreate()` and `onResume()`. See [Background work overview](/guide/background) for more\n information about available solutions for scheduling work on a background\n thread and communicating back with the UI.\n\n - Be careful when sharing thread pools between components. Don't use the same\n threads for potentially long-blocking operations and time-sensitive tasks\n such as broadcast receiving.\n\n | **Note:** Because such threading usually is accomplished at the class level, you can think of responsiveness as a class problem. Compare this with basic code performance, which is a method-level concern.\n- Keep app startup fast. Minimize slow or blocking operations in the app's\n startup code, such as methods run during dagger initialization.\n\n- If you're using `BroadcastReceiver`, consider running broadcast receivers in a\n non-main thread using [`Context.registerReceiver`](/reference/android/content/Context#registerReceiver(android.content.BroadcastReceiver,%20android.content.IntentFilter,%20java.lang.String,%20android.os.Handler,%20int)). For more information,\n see [ANRs in BroadcastReceiver](#anrs-in-broadcast-receiver).\n\n - If you use [`goAsync()`](/reference/android/content/BroadcastReceiver#goAsync()), make sure [`PendingResult.finish`](/reference/kotlin/android/content/BroadcastReceiver.PendingResult?#finish) is called quickly before the ANR timeout.\n\nANRs in BroadcastReceiver\n-------------------------\n\n`BroadcastReceiver` execution time is constrained because broadcast receivers\nare meant to do small, discrete amounts of work in the background, such as\nsaving a setting or registering a [`Notification`](/reference/android/app/Notification). So, as with other\nmethods called in the UI thread, apps must avoid potentially long-running\noperations or calculations in a broadcast receiver. Instead of performing\nlong-running tasks via the UI thread, perform them in the background for later\nexecution. See [Background work overview](/guide/background) for more information about possible\nsolutions.\n\nAnother common issue with `BroadcastReceiver` objects occurs when they execute\ntoo frequently. Frequent background execution can reduce the amount of memory\navailable to other apps. For more information about how to enable and disable\n`BroadcastReceiver` objects efficiently, see [Broadcasts overview](/guide/components/broadcasts).\n| **Tip:** You can use [`StrictMode`](/reference/android/os/StrictMode) to help find potentially lengthy operations such as network or database operations that you might accidentally be doing on your main thread.\n\nReinforce responsiveness\n------------------------\n\nGenerally, 100 to 200ms is the threshold beyond which users perceive slowness in\nan app. Here are additional tips for making your app seem responsive to users:\n\n- If your app is doing work in the background in response to user input, show\n that progress is being made, such as with a [`ProgressBar`](/reference/android/widget/ProgressBar) in your UI.\n\n- For games specifically, do calculations for moves in a worker thread.\n\n- If your app has a time-consuming initial setup phase, consider showing a\n [splash screen](/develop/ui/views/launch/splash-screen) or rendering the main view as quickly as possible.\n Indicate that loading is in progress and fill the information asynchronously.\n In either case, we recommend indicating somehow that progress is being made,\n so that the user doesn't perceive that the app is frozen.\n\n- Use performance tools such as [Perfetto](/topic/performance/tracing) and [CPU Profiler](/studio/profile/cpu-profiler) to\n determine bottlenecks in your app's responsiveness."]]