What methods can be used to avoid collisions when performing operations or accessing resources in a system?

To avoid collisions (conflicts) when performing operations or accessing shared resources in a system, various synchronization and concurrency control methods are used:

• Mutexes (Mutex) — lock a resource, allowing access to only one thread or process.
• Semaphores — limit the number of threads working with a resource simultaneously.
• Monitors and synchronized blocks (in Java/Android) — provide automatic locking and unlocking when entering/exiting a critical section.
• Atomic operations — operations that are performed as indivisible, preventing race conditions.
• Using message queues or events — for sequential processing of resource requests.
• Immutable objects — when working with data that does not change, to avoid conflicts.

Example of using synchronized in Android (Java/Kotlin):

private final Object lock = new Object();

public void safeMethod() {
    synchronized(lock) {
        // critical section
        // operations with shared resource
    }
}

Thus, the correct choice of mechanism depends on the specific task and performance requirements.