安卓之同步机制优劣分析

技术分享 2年前 (2023-12-18) 0 999+

关注

文章摘要

随着移动设备的普及，安卓操作系统已成为全球使用最广泛的移动操作系统之一。在安卓开发中，多线程编程是不可避免的，而同步机制则是确保多线程正确、高效运行的关键。本文将深入分析安卓中几种常见的同步机制，包括它们的优缺点，并提供相应的代码示例。

正文

synchronized 关键字

synchronized 是 Java 中的一种内置同步机制，它可以确保在同一时刻只有一个线程访问特定的代码块或方法。

优点

简单易用：只需要在方法或代码块前加上 synchronized 关键字。

可防止死锁：Java 虚拟机（JVM）在处理 synchronized 块时会自动处理锁的获取和释放顺序，从而降低死锁的风险。

缺点

性能较低，因为每次访问都需要获取和释放锁。

不支持更高级的同步需求，如可中断的锁、公平锁等。

控制粒度较粗：整个方法或代码块都被锁定，可能导致不必要的阻塞。

不支持超时等待：无法设置获取锁的超时时间。

非公平锁：默认情况下，synchronized 锁是非公平的，可能导致某些线程长时间等待。

代码示例

public class SynchronizedExample {  private int count = 0;  public synchronized void increment() {  count++;  }  public synchronized int getCount() {  return count;  }  }

ReentrantLock

ReentrantLock 是 java.util.concurrent.locks 包中的一个可重入锁，它提供了比 synchronized 更精细的锁定控制。

优点

支持可中断的锁、公平锁和非公平锁等高级同步需求。

性能较高，因为 ReentrantLock 使用了更高效的锁实现。

支持中断：可以通过调用 lockInterruptibly() 方法并在其他线程中中断等待的线程。

缺点

需要手动管理锁的获取和释放，增加了代码复杂度。

如果忘记释放锁，可能会导致死锁。

代码示例

import java.util.concurrent.locks.ReentrantLock;  public class ReentrantLockExample {  private int count = 0;  private ReentrantLock lock = new ReentrantLock();  public void increment() {  lock.lock();  try {  count++;  } finally {  lock.unlock();  }  }  public int getCount() {  lock.lock();  try {  return count;  } finally {  lock.unlock();  }  }  }

Semaphore

Semaphore 是一种计数信号量，用于控制同时访问特定资源的线程数量。信号量是一种计数器，用于控制多个线程对共享资源的访问。在安卓中，信号量主要用于实现进程间通信和同步。通过使用信号量，可以确保在多线程环境下，同一时刻只有一个线程能够访问共享资源，从而避免数据竞争和死锁等问题。

优点

支持多个线程之间的同步。

可以控制同时访问共享资源的线程数量。

支持超时等待和中断。

缺点

如果不使用 tryLock() 方法，可能会导致死锁。

不直接保护共享资源：需要额外的代码来确保资源的安全访问。

如果忘记释放信号量，可能会导致资源泄露。

代码示例

import java.util.concurrent.Semaphore;  public class SemaphoreExample {  private int count = 0;  private Semaphore semaphore = new Semaphore(1);  public void increment() {  semaphore.acquire();  try {  count++;  } finally {  semaphore.release();  }  }  public int getCount() {  semaphore.acquire();  try {  return count;  } finally {  semaphore.release();  }  }  }

CountDownLatch

优点

支持多个线程之间的同步。

可以等待多个线程完成操作。

缺点

仅适用于特定场景。

代码示例

import java.util.concurrent.CountDownLatch;  public class CountDownLatchExample {  private CountDownLatch latch = new CountDownLatch(1);  private int count = 0;  public void increment() {  count++;  latch.countDown();  }  public int getCount() {  return count;  }  }

Atomic 类

Java 提供了一系列原子操作类，如 AtomicInteger、AtomicLong 等，这些类提供的方法都是线程安全的。

优点

简单且高效：原子操作通常比使用锁更快。

避免了锁的竞争：由于原子操作不会阻塞，因此可以减少线程间的竞争。

缺点

功能有限：仅适用于简单的原子操作，如计数、更新等。

不能保护复杂的操作：对于涉及多个变量或更复杂的操作，原子类可能不够用。

代码示例

import java.util.concurrent.atomic.AtomicInteger;  public class AtomicIntegerExample {  private final AtomicInteger counter = new AtomicInteger(0);  public void increment() {  counter.incrementAndGet();  }  public void decrement() {  counter.decrementAndGet();  }  }

CyclicBarrier

优点

支持多个线程之间的同步。

可以等待多个线程完成操作。

缺点

仅适用于特定场景。

代码示例

import java.util.concurrent.CyclicBarrierExample;  public class CyclicBarrierExample {  private CyclicBarrier barrier = new CyclicBarrierExample(1);  private int count = 0;  public void increment() {  count++;  }  public int getCount() {  return count;  }

条件变量 (Condition Variable)

条件变量是一种同步机制，用于在一定条件下唤醒等待的线程。在安卓中，条件变量通常用于实现生产者-消费者模型，确保生产者和消费者之间的数据同步。

优点

允许线程在满足特定条件时被唤醒，适合生产者-消费者模型。

缺点

如果使用不当，可能导致虚假唤醒或死锁。

代码示例

Condition condition = lockObject.newCondition(); // 创建一个条件变量     // 生产者线程生产数据并唤醒消费者线程  condition.await(); // 等待条件满足，如果条件不满足则进入等待状态  // 生产数据并唤醒消费者线程  condition.signal(); // 唤醒等待的消费者线程     // 消费者线程等待数据并被生产者线程唤醒  condition.await(); // 等待条件满足，如果条件不满足则进入等待状态  // 处理数据并继续执行后续操作

读写锁 (Read-Write Lock)

优点

允许多读单写，提高了并发性能。

缺点

写操作可能受到读操作的阻塞。

代码示例

ReadWriteLock readWriteLock = new ReentrantReadWriteLock();     // 读线程  readWriteLock.readLock().lock(); // 获取读锁  try {  // 读取数据    } finally {  readWriteLock.readLock().unlock(); // 释放读锁    }     // 写线程类似，使用readWriteLock.writeLock()获取和释放写锁`