Fases e desempenho do Compose
Mantenha tudo organizado com as coleções
Salve e categorize o conteúdo com base nas suas preferências.
Quando o Compose atualiza um frame, ele passa por três fases:
- Composição:o Compose determina o que mostrar. Ele executa funções
combináveis e cria a árvore da interface.
- Layout:o Compose determina o tamanho e a posição de cada elemento na
árvore da interface.
- Exibição:o Compose renderiza os elementos da interface individuais.
O Compose pode ignorar essas fases de maneira inteligente se elas não forem necessárias. Por
exemplo, suponha que um único elemento gráfico alterne entre dois ícones do mesmo
tamanho. Como esse elemento não muda de tamanho e nenhum elemento da árvore da interface é
adicionado ou removido, o Compose pode pular as fases de composição e layout
e redesenhar esse único elemento.
No entanto, erros de programação podem dificultar que o Compose saiba quais fases ele
pode ignorar com segurança. Nesse caso, o Compose executa as três fases, o que pode deixar
a interface mais lenta. Portanto, muitas das práticas recomendadas de desempenho servem para ajudar o Compose
a pular as fases que ele não precisa fazer.
Para saber mais, consulte o guia Fases do Jetpack Compose.
Princípios gerais
Há alguns princípios gerais a serem seguidos que podem melhorar a performance em
geral:
- Sempre que possível, remova os cálculos das funções combináveis.
As funções combináveis podem precisar ser executadas novamente sempre que a interface mudar. Todo
código que você colocar no elemento combinável será executado novamente, possivelmente para cada frame
de uma animação. Limite o código do elemento combinável apenas ao necessário para criar
a interface.
- Adie as leituras de estado pelo maior tempo possível. Ao mover a leitura de estado para um
elemento combinável ou uma fase posterior, você pode minimizar a recomposição ou pular
completamente a fase de composição. Você pode fazer isso transmitindo funções lambda
em vez do valor do estado para mudar o estado com frequência e preferindo
modificadores baseados em lambda ao transmitir estados com mudanças frequentes. Confira
um exemplo dessa técnica na seção Adiar leituras pelo maior tempo possível
do artigo Seguir as práticas recomendadas.
Outros recursos
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,["# Compose phases and performance\n\nWhen Compose updates a frame, it goes through three phases:\n\n- **Composition:** Compose determines *what* to show. It runs composable functions and builds the UI tree.\n- **Layout:** Compose determines the size and placement of each element in the UI tree.\n- **Drawing:** Compose actually *renders* the individual UI elements.\n\nCompose can intelligently skip any of those phases if they aren't needed. For\nexample, suppose a single graphic element swaps between two icons of the same\nsize. Since this element isn't changing size, and no elements of the UI tree are\nbeing added or removed, Compose can skip over the composition and layout phases\nand redraw this one element.\n\nHowever, coding mistakes can make it hard for Compose to know which phases it\ncan safely skip, in which case Compose runs all three phases, which can slow\ndown your UI. So, many of the performance best practices are to help Compose\nskip the phases it doesn't need to do.\n\nFor more information, see the [Jetpack Compose Phases](/develop/ui/compose/phases) guide.\n\nGeneral principles\n------------------\n\nThere are a couple of broad principles to follow that can improve performance in\ngeneral:\n\n- **Whenever possible, move calculations out of your composable functions.** Composable functions might need to be rerun whenever the UI changes. Any code you put in the composable gets re-executed, potentially for every frame of an animation. Limit the composable's code to only what it needs to build the UI.\n- **Defer state reads for as long as possible.** By moving state reading to a child composable or a later phase, you can minimize recomposition or skip the composition phase entirely. You can do this by passing lambda functions instead of the state value for frequently changing state and by preferring lambda-based modifiers when you pass in frequently changing state. You can see an example of this technique in the [Defer reads as long as possible](/develop/ui/compose/performance/bestpractices#defer-reads) section of [Follow best practices](/develop/ui/compose/performance/bestpractices).\n\nAdditional Resources\n--------------------\n\n- **[App performance guide](/topic/performance/overview)**: Discover best practices, libraries, and tools to improve performance on Android.\n- **[Inspect Performance](/topic/performance/inspecting-overview):** Inspect app performance.\n- **[Benchmarking](/topic/performance/benchmarking/benchmarking-overview):** Benchmark app performance.\n- **[App startup](/topic/performance/appstartup/analysis-optimization):** Optimize app startup.\n- **[Baseline profiles](/baseline-profiles):** Understand baseline profiles."]]