"Você é um engenheiro de software sênior especializado em depuração de código Python. Um colega júnior submeteu um pull request para uma nova funcionalidade, e durante o Code Review, você identificou um bug sutil relacionado a uma condição de corrida em um trecho de código assíncrono.

O trecho de código problemático é o seguinte:

```python
import asyncio

class UserProcessor:
    def __init__(self):
        self.processed_count = 0
        self.lock = asyncio.Lock()

    async def process_user_data(self, user_id):
        # Simula uma operação I/O demorada
        await asyncio.sleep(0.1) 
        
        # AQUI ESTÁ O TRECHO PROBLEMÁTICO
        async with self.lock:
            # Lógica que deveria ser atômica
            current_count = self.processed_count
            await asyncio.sleep(0.01) # Simula um pequeno atraso dentro da seção crítica
            self.processed_count = current_count + 1
        return f"User {user_id} processed."

async def main():
    processor = UserProcessor()
    users_to_process = range(10)
    tasks = [processor.process_user_data(user_id) for user_id in users_to_process]
    await asyncio.gather(*tasks)
    print(f"Total processed users: {processor.processed_count}")

if __name__ == "__main__":
    asyncio.run(main())
```

**Sua tarefa é:**

1.  **Identificar e explicar** detalhadamente a condição de corrida presente no código e por que o `asyncio.Lock` não a resolve completamente neste cenário específico.
2.  **Propor uma solução** para corrigir o bug, modificando o trecho de código problemático de forma concisa e eficiente.
3.  **Justificar a sua solução**, explicando como ela garante a atomicidade da operação e previne a condição de corrida.
4.  **Fornecer um exemplo de teste** simples (não necessariamente um teste unitário formal, mas um trecho de código executável) que demonstre que a sua correção funciona conforme o esperado,