Java 中同步机制的几种方式及使用

最新推荐文章于 2024-04-30 17:28:01 发布

IT徐师兄

最新推荐文章于 2024-04-30 17:28:01 发布

阅读量3k

点赞数

文章标签： java

本文链接：https://blog.csdn.net/yujun2023/article/details/130666731

版权

在Java中，同步机制是用来解决多线程并发访问共享资源的问题。如果多个线程同时访问共享资源，可能会导致数据不一致、死锁等问题。Java中提供了多种同步机制，例如synchronized关键字、Lock接口、Semaphore类、CountDownLatch类等。本文将介绍Java中常见的同步机制，并讨论它们的使用方法和注意事项。

在这里插入图片描述

synchronized关键字

synchronized关键字是Java中最常见的同步机制。它可以用于同步方法和同步代码块，使得多个线程可以按照一定的顺序访问共享资源，从而避免线程之间的竞争和冲突。

同步方法

在Java中，可以使用synchronized关键字来同步方法。如果一个方法被标记为synchronized，那么同一时间只能有一个线程执行该方法。其他线程必须等待该线程执行完毕后才能继续执行。

public synchronized void foo() {
    // Synchronized method implementation
}

这个示例中，我们定义了一个同步方法foo。由于该方法被标记为synchronized，因此同一时间只能有一个线程执行该方法。

同步代码块

除了同步方法，还可以使用synchronized关键字来同步代码块。如果一个代码块被标记为synchronized，那么同一时间只能有一个线程执行该代码块。其他线程必须等待该线程执行完毕后才能继续执行。

public void foo() {
    synchronized (this) {
        // Synchronized code block implementation
    }
}

这个示例中，我们定义了一个同步代码块，使用this作为锁对象。由于该代码块被标记为synchronized，因此同一时间只能有一个线程执行该代码块。

锁对象

在Java中，每个对象都有一个锁对象。当一个线程访问一个对象时，它会自动获取该对象的锁对象。如果该对象已经被其他线程占用，则当前线程必须等待，直到锁对象被释放为止。

public class MyObject {
    public synchronized void foo() {
        // Synchronized method implementation
    }
}

public class MyThread extends Thread {
    private MyObject obj;

    public MyThread(MyObject obj) {
        this.obj = obj;
    }

    public void run() {
        obj.foo();
    }
}

MyObject obj = new MyObject();
MyThread t1 = new MyThread(obj);
MyThread t2 = new MyThread(obj);
t1.start();
t2.start();

这个示例中，我们定义了一个MyObject类，其中包含一个同步方法foo。我们创建了两个线程t1和t2，它们都访问同一个MyObject对象。由于该对象的锁对象只有一个，因此t1和t2必须按照一定的顺序访问该对象。

注意事项

使用synchronized关键字时需要注意以下几点：

锁对象的范围应该尽量小，以减少锁的竞争和等待时间。
锁对象可以是任意对象，但是多个线程必须使用同一个锁对象。
如果一个方法或代码块被标记为synchronized，那么它的性能可能会受到影响，因为其他线程必须等待该线程执行完毕后才能继续执行。
如果一个线程执行了一个synchronized方法或代码块，那么它会自动释放该对象的锁对象。如果一个线程执行了一个非同步方法或代码块，那么它并不会自动释放该对象的锁对象。

Lock接口

除了synchronized关键字，Java还提供了Lock接口来实现同步机制。Lock接口提供了更多的功能和灵活性，可以满足更多的需求和场景。

获取锁和释放锁

Lock接口提供了两个方法来获取锁和释放锁：

lock()：获取锁，如果锁已经被占用，则当前线程会等待，直到锁被释放。
unlock()：释放锁。

Lock lock = new ReentrantLock();
lock.lock();
try {
    // Synchronized code block implementation
} finally {
    lock.unlock();
}

这个示例中，我们使用ReentrantLock类来创建一个锁对象，然后使用lock()方法获取锁，使用try-finally语句块来执行同步代码块，最后使用unlock()方法释放锁。

尝试获取锁

Lock接口还提供了一个tryLock()方法，用于尝试获取锁。如果锁已经被占用，则该方法会立即返回false，而不是等待。

java

Copy

Lock lock = new ReentrantLock();
if (lock.tryLock()) {
    try {
        // Synchronized code block implementation
    } finally {
        lock.unlock();
    }
} else {
    // Handle lock not acquired
}

这个示例中，我们使用tryLock()方法尝试获取锁，如果获取成功，则执行同步代码块。否则，我们可以处理锁未获取的情况。

公平锁和非公平锁

Lock接口提供了两种锁：公平锁和非公平锁。公平锁会按照线程请求的顺序分配锁，而非公平锁则不保证按照请求的顺序分配锁。

java

Copy

Lock fairLock = new ReentrantLock(true);
Lock nonFairLock = new ReentrantLock(false);

这个示例中，我们创建了两个锁对象，一个是公平锁，另一个是非公平锁。

注意事项

使用Lock接口时需要注意以下几点：

Lock接口提供了更多的功能和灵活性，但也增加了代码的复杂度和风险。
如果一个线程获取了锁，但是没有及时释放锁，其他线程可能会一直等待，导致死锁等问题。
Lock接口不同于synchronized关键字，它不会自动释放锁，必须手动释放锁，否则可能会导致死锁等问题。
Lock接口不同于synchronized关键字，它支持中断等待锁的线程，可以更加灵活地处理线程的中断请求。

Semaphore类

Semaphore类是Java中另一个常见的同步机制。它可以用于控制同时访问某个资源的线程数量，从而避免资源的过度占用和竞争。

获取许可证和释放许可证

Semaphore类提供了两个方法来获取许可证和释放许可证：

acquire()：获取一个许可证，如果没有许可证可用，则当前线程会等待，直到有许可证可用。
release()：释放一个许可证。

Semaphore semaphore = new Semaphore(10);
semaphore.acquire();
try {
    // Synchronized code block implementation
} finally {
    semaphore.release();
}

这个示例中，我们创建了一个Semaphore对象，初始值为10，表示最多有10个线程可以同时访问某个资源。然后使用acquire()方法获取许可证，使用try-finally语句块来执行同步代码块，最后使用release()方法释放许可证。