当前位置：首页 > article >正文

Java中synchronized与Lock的区别与使用

article 2024/11/15 12:50:33

Java中synchronized与Lock的区别与使用

当我们谈论Java多线程编程时，线程同步是一个避免资源竞争和保证线程安全的关键概念。在Java中，主要有两种机制来实现线程同步：synchronized关键字和Lock接口。这篇博客将详细介绍这两种同步机制的区别和使用方法，并通过示例来加深理解。

synchronized关键字

synchronized是Java语言内置的同步机制，它基于进入和退出监视器对象（monitor）的概念来提供对代码块或方法的互斥访问。当线程进入一个synchronized方法或代码块时，它会自动获得锁，退出时释放锁。

synchronized方法

当一个方法被声明为synchronized时，它会锁定调用该方法的对象（对于实例方法）或锁定该方法所属的类的Class对象（对于静态方法）。

public class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public synchronized int getCount() {
        return count;
    }
}

在上面的例子中，increment和getCount方法都是同步的，这意味着同一时刻只有一个线程可以执行这些方法中的任何一个。

synchronized代码块

synchronized也可以用来同步代码块而不是整个方法。

public class Counter {
    private int count = 0;
    private final Object lock = new Object();

    public void increment() {
        synchronized(lock) {
            count++;
        }
    }

    public int getCount() {
        synchronized(lock) {
            return count;
        }
    }
}

在这个例子中，我们使用一个私有的锁对象来同步代码块。这种方式提供了更细粒度的控制，可以减少不必要的同步开销。

Lock接口

Lock接口提供了比synchronized更复杂的锁定操作。它允许更灵活的结构，可以尝试非阻塞地获取锁，可以中断锁获取等待，还可以实现公平锁等。

ReentrantLock

ReentrantLock是Lock接口的一个实现，它具有与synchronized相似的基本行为和语义，但增加了扩展功能。

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Counter {
    private int count = 0;
    private final Lock lock = new ReentrantLock();

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }

    public int getCount() {
        lock.lock();
        try {
            return count;
        } finally {
            lock.unlock();
        }
    }
}

在上面的例子中，我们使用ReentrantLock来保护对count变量的访问。注意lock()和unlock()方法的使用，以及unlock()总是在finally块中调用以确保锁定一定会被释放。

公平锁和非公平锁

ReentrantLock允许创建公平锁和非公平锁。公平锁意味着线程将按照它们请求锁的顺序获取锁，而非公平锁则不保证这一点。

private final Lock fairLock = new ReentrantLock(true); // 公平锁
private final Lock unfairLock = new ReentrantLock(); // 非公平锁（默认）

使用公平锁可能会降低性能，但可以减少线程饥饿。

尝试锁定

Lock接口提供了tryLock()方法，允许线程尝试获取锁而不是无限期等待。

public void increment() {
    if (lock.tryLock()) {
        try {
            count++;
        } finally {
            lock.unlock();
        }
    } else {
        // 无法获取锁时执行的操作
    }
}

synchronized与Lock的区别

锁的控制精细度：synchronized关键字自动管理锁的获取和释放，而Lock接口提供了更精细的控制，允许尝试锁定、定时锁定和其他高级功能。
性能：在Java 5以前，synchronized性能较差，但随着JVM的优化，现在synchronized和ReentrantLock的性能已经相当接近。
条件变量支持：Lock接口可以与Condition接口一起使用，提供类似wait/notify的功能，但更灵活。
锁的公平性：ReentrantLock提供了创建公平锁的选项，而synchronized总是创建非公平锁。
锁的中断处理：Lock接口允许在等待锁的过程中响应中断，而synchronized不支持。

何时使用synchronized，何时使用Lock

一般来说，如果需要简单的互斥同步，synchronized是一个很好的选择，因为它更容易理解和使用。当需要更高级的特性，如尝试锁定、定时锁定、中断等待锁的线程或实现公平锁时，应该选择Lock接口。

总结

synchronized和Lock都是Java中实现线程同步的重要工具。选择哪一个取决于具体的需求和场景。synchronized更适合代码简洁和少量的同步任务，而Lock提供了更多的灵活性和高级控制，适合复杂的同步需求。无论选择哪种同步机制，始终要确保锁定策略简单，避免死锁，并且合理地管理锁的范围以提高效率。

希望这篇博客能够帮助你更好地理解和使用Java中的synchronized和Lock。记住，正确使用同步机制是编写健壮、线程安全的多线程应用程序的关键。

查看全文

http://www.kler.cn/a/156706.html