Os processos de apps no Android não existem de forma isolada. Os apps geralmente dependem de serviços fornecidos por outros apps ou pelo próprio sistema. Quando um processo se conecta a outro usando uma vinculação de serviço, ele cria uma dependência que tem um impacto profundo na forma como o framework do Android gerencia a memória.
Estados de processo e pontuações de OOM
O framework do Android usa estados de processo para monitorar a importância de cada
processo em execução. Esses estados são usados pelo OomAdjuster para atribuir um valor de
ajuste de pontuação de OOM (oom_score_adj), que varia de -1.000 a 1.000.
Um oom_score_adj menor significa que o processo é mais importante e tem menos probabilidade de
ser encerrado pelo Low Memory Killer (LMK).
Estados de processo comuns
A tabela a seguir mostra alguns dos estados de processo mais comuns e os valores típicos de oom_score_adj. Para uma lista completa e atualizada, consulte
android.app.ActivityManager e com.android.server.am.psc.Constants no
código-fonte do Android.
| Estado do processo (sigla) | Descrição | oom_score_adj típico |
|---|---|---|
| PER (persistente) | Processos do sistema que precisam ser sempre executados (por exemplo, telefonia). | -800 |
| TOP | O processo com que o usuário está interagindo no momento. | 0 |
| VIS (visível) | O processo tem uma atividade visível (por exemplo, atrás de uma caixa de diálogo translúcida). | 100 |
| PERC (Perceptível) | Processo em segundo plano de que o usuário está ciente (por exemplo, reprodução de música). | 200 |
| FGS | Processo que hospeda um serviço em primeiro plano. | 0 a 200 (varia) |
| BTOP (Bound Top) | Processo vinculado por um aplicativo TOP. | 100 |
| BFGS | Serviço em primeiro plano vinculado (geralmente vinculado ao sistema). | 0 |
| PREV (Anterior) | O último processo em que o usuário estava antes do atual. | 700 |
| CACHED | Apps em segundo plano que podem ser encerrados com segurança. | 900 a 999 |
O impacto das vinculações de serviço
Quando um processo do cliente (por exemplo, um app no estado TOP) se vincula a um serviço em um
processo do servidor, o processo do servidor geralmente herda uma prioridade elevada. Isso
garante que o serviço permaneça disponível enquanto o cliente precisar dele.
Como controlar a herança com flags BIND
A herança é o comportamento padrão ao usar Context.BIND_AUTO_CREATE.
No entanto, os desenvolvedores podem controlar como a vinculação afeta a importância do processo de destino
usando várias flags em bindService().
Principais flags de BIND para pontuação de OOM
As flags a seguir são as mais relevantes ao gerenciar a pressão de memória em todo o sistema:
BIND_AUTO_CREATE: a flag mais comum. Ele garante que o processo do serviço seja iniciado e mantido ativo enquanto a vinculação existir. Por padrão, ele também eleva a prioridade do processo do servidor para corresponder ao cliente.BIND_NOT_FOREGROUND: impede que o processo do serviço de destino seja elevado para a prioridade de programação em primeiro plano (prioridade da CPU). No entanto, ele ainda permite que a prioridade de memória (oom_score_adj) seja elevada. Isso é útil para trabalhos em segundo plano que não devem competir com a IU por ciclos de CPU, mas ainda precisam ser protegidos contra encerramento.BIND_WAIVE_PRIORITY: uma flag muito forte que instrui o sistema a não afetar a prioridade de programação ou de gerenciamento de memória do processo de destino. O processo de serviço será gerenciado como se fosse um processo em segundo plano normal na lista LRU, tornando-o qualificado para encerramento por OOM, mesmo quando vinculado.BIND_ABOVE_CLIENT: indica que o serviço é mais importante do que o próprio app cliente. Quando o sistema precisa recuperar memória, ele prefere encerrar o app cliente antes de encerrar o serviço vinculado. Isso é "mais forte" do queBIND_AUTO_CREATE, porque fornece uma camada extra de proteção para o serviço às custas do cliente.BIND_NOT_PERCEPTIBLE: reduz a importância do serviço de destino para abaixo do nívelPERCEPTIBLE, permitindo que o sistema recupere a memória para abrir espaço para processos mais críticos perceptíveis ao usuário.
Prática: observar os efeitos da vinculação
As etapas a seguir usam o app MemoryLab para mostrar como uma vinculação de um
app TOP afeta o estado de um processo separado.
1. Iniciar o MemoryLab
O comando a seguir inicia o app. Depois que ele abrir, mantenha o app em primeiro plano (não pressione o botão home nem mude de app ainda).
adb shell am start -n com.android.memorylab/.MainActivity
2. Identificar processos
Verifique os estados do processo antes de vincular. O MemoryLab executa a interface principal em um
processo e tem um RemoteService que é executado em um processo :remote.
adb shell dumpsys activity processes com.android.memorylab
Exemplo de snippet de saída:
Process OOM control (154 total, non-act at 7, non-svc at 7):
Proc #0: fg T/A/TOP LCMNFUATI t: 0 13470:com.android.memorylab/u0a417 (top-activity)
oom: max=1001 curRaw=0 setRaw=0 cur=0 set=0
state: cur=TOP set=TOP lastRss=0.00 lastCachedRss=0.00
Você vai encontrar o processo principal com.android.memorylab no estado TOP. O processo :remote ainda não foi iniciado.
3. Vinculação de gatilho
Envie uma transmissão para o app para acionar a vinculação de serviço:
adb shell am broadcast -a com.android.memorylab.LEAK_BINDER
4. Observar o estado elevado
Verifique os estados do processo novamente:
adb shell dumpsys activity processes | grep -A 10 "com.android.memorylab"
Exemplo de snippet de saída:
Proc # 1: vis F/ /BTOP ---NFUATI t: 0 13560:com.android.memorylab:remote/u0a417 (service)
com.android.memorylab/.RemoteService<=Proc{13470:com.android.memorylab/u0a417}
oom: max=1001 curRaw=100 setRaw=100 cur=100 set=100
state: cur=BTOP set=BTOP lastRss=0.00 lastCachedRss=0.00
O processo :remote agora está em execução e no estado BTOP (Bound TOP) com
um oom_score_adj de 100. Isso é significativamente mais protegido do que um
serviço em segundo plano típico (que estaria em 500 ou mais). A notação
<=Proc{...} mostra qual processo é responsável por essa elevação de prioridade.
5. Enviar para segundo plano
Pressione o botão HOME no dispositivo. Verifique os estados novamente:
adb shell dumpsys activity processes | grep -A 10 "com.android.memorylab"
Exemplo de snippet de saída:
Proc # 2: prev b/ /LAST --------I t: 0 13560:com.android.memorylab:remote/u0a417 (service)
com.android.memorylab/.RemoteService<=Proc{13470:com.android.memorylab/u0a417}
oom: max=1001 curRaw=700 setRaw=700 cur=700 set=700
state: cur=LAST set=LAST lastRss=0.00 lastCachedRss=0.00
Proc # 1: prev b/ /LAST --------I t: 0 13470:com.android.memorylab/u0a417 (previous)
oom: max=1001 curRaw=700 setRaw=700 cur=700 set=700
state: cur=LAST set=LAST lastRss=209MB lastCachedRss=0.00
Agora, os dois processos mudaram para um estado de prioridade mais baixa (PREV /
oom_score_adj 700), porque o processo do cliente não é mais TOP. Observação:
LAST no despejo de estado se refere ao estado interno LAST_ACTIVITY, que
é mapeado para PREV em resumos de alto nível.
Análise com o procstats
A ferramenta procstats oferece uma visualização histórica desses estados.
# View stats for MemoryLab over the last hour
adb shell dumpsys procstats --hours 1 com.android.memorylab
Exemplo de snippet de saída:
* com.android.memorylab / u0a417 / v37:
* Prc com.android.memorylab / u0a417 / v37:
TOTAL: 0.89% (0.00-0.00-0.00/0.00-0.00-0.00/210MB-210MB-210MB over 1)
Top: 0.89% (0.00-0.00-0.00/0.00-0.00-0.00/210MB-210MB-210MB over 1)
* Prc com.android.memorylab:remote / u0a417 / v37:
TOTAL: 0.19%
Bnd Top: 0.19%
Nesse caso, Bnd Top indica a porcentagem de tempo que o processo remoto passou
vinculado a um aplicativo no estado TOP.
Como capturar e analisar vinculações com o Perfetto
Embora o dumpsys forneça um resumo, o Perfetto permite que você veja o momento exato
em que uma vinculação ocorre e como a pontuação de OOM muda em tempo real.
1. Gravar um rastro
Use uma configuração que inclua linux.process_stats e a categoria atrace
am:
adb shell perfetto -c - --txt -o /data/misc/perfetto-traces/service_bindings.perfetto-trace <<EOF
buffers: { size_kb: 65536 }
data_sources: {
config {
name: "linux.process_stats"
process_stats_config { proc_stats_poll_ms: 100 }
}
}
data_sources: {
config {
name: "linux.ftrace"
ftrace_config { ftrace_events: "am/am_proc_bound" }
}
}
duration_ms: 15000
EOF
2. Consultar transições de pontuação de OOM
Usando o PerfettoSQL, é possível ver como a pontuação de OOM do processo remoto mudou em relação ao processo da interface:
SELECT ts, p.name, value AS oom_score_adj
FROM counter c
JOIN process_counter_track t ON c.track_id = t.id
JOIN process p USING (upid)
WHERE p.name LIKE 'com.android.memorylab%'
AND t.name = 'oom_score_adj'
ORDER BY ts;
3. Identificar eventos de vinculação
Para ver exatamente quando uma dependência de vinculação foi estabelecida e qual processo a iniciou, use esta consulta:
SELECT
s.ts,
p.name AS process_name,
t.name AS thread_name,
s.name AS slice_name
FROM slice s
JOIN thread_track tt ON s.track_id = tt.id
JOIN thread t USING (utid)
JOIN process p USING (upid)
WHERE s.name LIKE 'bindService:{com.android.memorylab%';
Vinculações do sistema ao app
O próprio sistema Android geralmente se vincula a serviços em apps de terceiros para fornecer funcionalidades principais. Muitas vezes, o objetivo dessas vinculações é a redução da latência. Ao manter um processo ativo e na memória, o sistema evita a sobrecarga de uma "inicialização a frio" (carregar o APK, inicializar o ambiente de execução e criar o objeto Application) quando ocorre uma interação crítica do usuário. Existem outras vinculações para evitar inicializações a frio frequentes em apps que precisam processar streams de eventos em segundo plano.
Confira alguns exemplos reais que você pode observar em um dispositivo típico:
VoiceInteractionService
Os usuários esperam que um assistente digital seja incorporado ao SO do smartphone, que possa ser invocado instantaneamente com uma hotword falada ou um gesto de entrada rápido e que a interação seja tranquila e integrada.
Quando um acionador do assistente ocorre (como a hotword "Ok Google" em smartphones
Google Pixel), o assistente digital precisa responder instantaneamente. Para garantir isso,
o system_server mantém uma vinculação permanente com o
VoiceInteractionService selecionado pelo usuário.
Se você verificar os estados do processo (por exemplo, usando dumpsys activity processes), poderá
ver um processo como com.google.android.googlequicksearchbox:interactor no
estado BFGS (serviço em primeiro plano vinculado), mantido ativo por uma vinculação de
system_server (UID 1000).
NotificationListenerService
Para algumas vinculações de sistema para app, o objetivo não é a latência, mas sim evitar
inicializações a frio frequentes.
NotificationListenerService,
um serviço que recebe chamadas do sistema quando novas notificações são postadas
ou removidas, é um excelente exemplo. Um usuário comum de smartphone pode receber centenas
de notificações ao longo do dia. Se o sistema se desvincular de um listener de notificações, o processo desse app provavelmente vai entrar no estado em cache e poderá ser
encerrado pelo LMK.
Quando a próxima notificação chegasse, possivelmente segundos depois, o sistema seria forçado a fazer uma inicialização a frio do processo do app novamente só para entregar o evento. Esse ciclo constante de encerramento e inicialização a frio consumiria muito mais CPU e bateria do que manter o processo vinculado e ativo em segundo plano.
A "tela -1" do acesso rápido (feed de notícias)
Os apps de tela de início modernos geralmente combinam a funcionalidade de navegação principal (ícones e widgets da tela inicial) com um feed de notícias disponível em uma das telas e integrado à UX da tela de início. O feed de notícias pode ser fornecido por outro app. Por exemplo, no Google Pixel, o acesso rápido se integra a um feed fornecido pelo app do Google.
Quando você desliza para a esquerda na tela inicial para ver o feed de notícias, a transição precisa ser suave. Para isso, o inicializador se vincula a uma interface de serviço no app que fornece o feed de notícias e mantém essa vinculação ativa enquanto o inicializador estiver ativo. Isso mantém o conteúdo do feed renderizado e pronto na memória, mesmo quando você não está olhando para ele.
Outros exemplos comuns
- A tela de início (HOME_APP_ADJ): o app de início (Home) tem um espaço especial
na lista de prioridades. Embora nem sempre esteja vinculado a um serviço, ele recebe o
HOME_APP_ADJ(normalmente 600). O sistema prefere manter o acesso rápido ativo, porque o usuário o acessa com frequência. Na verdade, o sistema prefere encerrar o app usado anteriormente (PREV_APP_ADJ = 700) em vez de encerrar o inicializador, porque isso resultaria em uma experiência lenta para o usuário ao sair de qualquer app, já que ele precisaria esperar que o inicializador fosse iniciado a frio. - Editor de método de entrada (IME): quando você digita, o sistema se vincula ao app de teclado escolhido (por exemplo, o Gboard). Isso mantém o processo do teclado em um estado elevado, mesmo que o teclado esteja temporariamente oculto. Isso garante que o teclado possa reaparecer instantaneamente quando você tocar em outro campo de texto.
- Pagamentos por aproximação: quando você encosta o smartphone para pagar, o sistema se vincula ao serviço de pagamento por aproximação (por exemplo, a Carteira do Google). Essas transações geralmente têm requisitos rígidos em tempo real do terminal do comerciante. Se o app de pagamento precisasse de uma inicialização a frio, a transação poderia expirar e falhar.
Compensações e o limite de desempenho
Embora as vinculações sejam necessárias para o desempenho e a precisão, elas têm um custo para a integridade da memória do sistema.
- Flexibilidade reduzida: cada processo vinculado é um processo que o LMK não pode encerrar facilmente. Isso reduz a "reserva" de processos em cache que o sistema pode usar para liberar memória sob pressão.
- Agravamento do limite de desempenho: se muitos processos estiverem vinculados, o sistema poderá ficar quase sem processos em segundo plano que podem ser encerrados. Quando a pressão da memória aumenta, o sistema "cai do penhasco de desempenho" muito mais rápido, já que é forçado a encerrar processos mais importantes ou sobrecarregar o cache de páginas.
Antipadrões comuns de vinculação de serviço
Como as vinculações de serviço elevam diretamente o oom_score_adj, erros sutis de ciclo de vida
na forma como você adquire ou estrutura vinculações podem fixar grandes quantidades de
memória em estados privilegiados (BTOP, BFGS ou PERC) por horas. Cuidado
com esses antipadrões comuns ao projetar ou auditar serviços vinculados.
unbindService() esquecido em clientes de longa duração
A vinculação a um serviço de um singleton Application, um gerenciador em segundo plano ou
um Activity que chama bindService em onStart sem um
unbindService correspondente em onStop vaza o ServiceConnection.
Enquanto essa vinculação permanecer ativa, o processo de destino vai herdar a
prioridade elevada do cliente. Se o cliente for um componente de sistema persistente ou um aplicativo em primeiro plano, o processo de serviço vinculado vai permanecer fixado em BFGS ou BTOP indefinidamente (aparecendo perto de 100% em procstats), impedindo que o LMK recupere a memória, mesmo quando o serviço estiver completamente inativo.
Solução: limite as vinculações ao ciclo de vida do componente que
precisa delas ou implemente um tempo limite de inatividade que chame unbindService() após um
período de inatividade. Evite desvincular e vincular novamente em cada chamada RPC
individual, o que causa sobrecarga de processo e sobrecarga repetida de configuração do Binder.
Em vez disso, agrupe as intermitências de trabalho em um curto timer de inatividade (por exemplo, de 5 a
30 segundos).
Colocar um serviço vinculado com uma interface que consome muita memória
Por padrão, todos os componentes em um APK são executados no mesmo processo. Se o app
expõe um serviço vinculado leve (como um NotificationListenerService, um
provedor de widgets ou um serviço de plug-in ao qual o sistema ou o acesso rápido se vincula) no
mesmo processo que o Activity principal, todo o processo herda o
estado elevado do serviço (BFGS ou PERC, normalmente oom_score_adj de 200 ou
menos).
Quando o usuário abre a interface do app, o processo aloca grandes hierarquias de visualização,
bitmaps decodificados e buffers gráficos. Quando o usuário sai, o processo não cai para CACHED (oom_score_adj de 900 ou mais)
porque a vinculação de serviço ativa mantém o processo elevado. Isso causa dois
problemas cumulativos:
- Sem compactação de memória em segundo plano: o
CachedAppOptimizerdo sistema só compacta processos depois que eles entram no estadoCACHED. - Sem corte de memória de LRU em cache ou oculto pela interface: quando uma vinculação de serviço mantém
o processo em
BFGSouPERC, o sistema não envia callbacks de corte de LRU em cache ouTRIM_MEMORY_UI_HIDDEN, comoTRIM_MEMORY_BACKGROUND. Se o app não liberar recursos de IU quando ela deixar de ficar visível, as alocações de pico da IU vão permanecer fixadas na RAM em uma pontuação de OOM privilegiada, em que o LMK não pode recuperá-las.
Solução: remova caches de interface, bitmaps decodificados e referências de visualização quando a interface
deixar de ser visível usando Activity.onStop,
Application.ActivityLifecycleCallbacks ou
ProcessLifecycleOwner. Como alternativa, mova o
serviço sempre vinculado para um processo separado e leve usando o
atributo de manifesto android:process para que o sistema possa mover o processo principal da interface
para o estado CACHED para compactar ou recuperar a memória
de forma independente.
Omissão de flags de renúncia de prioridade
Chamar bindService() apenas com BIND_AUTO_CREATE transfere toda a prioridade de programação e memória do autor da chamada para o serviço de destino. Quando um app em primeiro plano
se vincula a um serviço de análise, geração de registros ou pré-busca em segundo plano usando apenas
BIND_AUTO_CREATE, ele promove involuntariamente esse worker em segundo plano para
BTOP.
Solução: ao vincular a serviços auxiliares ou de melhor esforço que não precisam
do mesmo nível de proteção que a interface em primeiro plano, combine BIND_AUTO_CREATE com
BIND_WAIVE_PRIORITY, BIND_NOT_FOREGROUND ou BIND_NOT_PERCEPTIBLE para que o
sistema ainda possa gerenciar o processo de destino na lista de LRU em cache.
← Localidade | ↑ Para cima | Em todo o sistema →