Concurrency and synchronization evaluation on android

A consolidação do mercado de smartphones ampliou o acesso das pessoas à computação. Um dos principais objetivos das aplicações desenvolvidas para esse mercado é proporcionar uma boa experiência ao usuário. Uma aplicação precisa manter a sua interface fluída com feedback imediato para que possa fornecer uma boa experiência de usuário. A partir do momento que tarefas custosas passam a ser executadas nesse ambiente, essas características somente se tornam possíveis quando a aplicação inicia fluxos de execução concorrentes para que essas tarefas executem em background sem interromper a interação da aplicação com o usuário. Dessa forma, o objetivo desse trabalho é avaliar alguns mecanismos para criação e gerenciamento desses fluxos de concorrência no sistema operacional Android, que é o sistema operacional mais utilizado para smartphones. Para tanto, considera diferentes testes para avaliar mecanismos como Threads, framework HaMeR, Thread Pool, Kotlin Coroutines, IntentServices e AsyncTasks. Considerando características como sua escalabilidade frente aos recursos paralelos de hardware, o uso eficiente de recursos de rede, a sobrecarga introduzida para realizar o gerenciamento de muitos fluxos concorrentes e a sua justiça na distribuição de recursos entre os fluxos concorrentes. Além disso, serão avaliados mecanismos tradicionais de sincronização, como Semáforos, Lock e Condition, blocos Synchronized de Kotlin e variáveis atômicas, no contexto de aplicações móveis para Android. Os resultados obtidos indicam que existe um ganho de escalabilidade no uso de recursos paralelos ao se usar Kotlin coroutines, contudo existe uma alta sobrecarga durante a execução dos fluxos concorrentes ao se usar esse mecanismo. Indicam também que o HaMeR framework tende a ser mais justo para gerenciar um cenário com muitos fluxos competindo pela obtenção de recursos. Indicam ainda que o uso de semáforos introduz uma sobrecarga menor do que os outros mecanismos de sincronização quando tarefas com diferentes funções operam em um ambiente cooperativo.The consolidation of the smartphone market has expanded people’s access to computation. One of the main goals of the applications developed for this market is to provide a good user experience. An application needs to provide a fluid user interface and immediate feedback in order to provide a good user experience. Once costly tasks are executed in mobile environments, these characteristics only become possible when the application starts concurrent executions streams allowing these tasks to execute in the background without disrupting the application’s interaction with the user. Thus, the purpose of this work is to evaluate some mechanics for creating and managing these concurrent execution streams in the Android operating system, that is the most used operating system for smartphones. Therefore, it considers different tests to evaluate mechanisms such as Threads, HaMeR framework, Thread Pool, Kotlin Coroutines, IntentServices and AsyncTasks. Considering characteristics such as its scalability against parallel hardware resources, the efficient use of network resources, the overhead introduced to perform the management of many concurrent executions and fairness of resource distribution among concurrent execution stream. In addition, traditional synchronization mechanisms, such as Semaphores, Lock and Condition, Kotlin’s Synchronized blocks and atomic variables, will be evaluated in the context of Android mobile applications. The obtained results indicate that there is a scalability gain in the use of parallel resources when using Kotlin coroutines, however there is an introduction of overhead when running concurrent execution streams using this mechanism. They also indicate that HaMeR framework tends to be fairer to managing a scenario with multiples execution streams competing for resources. The results also show that using semaphores introduces a lower overhead than other synchronization mechanisms when tasks with different functions operate in a cooperative environment