多线程_线程的互斥同步_多线程中的同步互斥方法-CSDN博客

本文链接：https://blog.csdn.net/xwshappy/article/details/132011349

线程的互斥同步

Java 提供了两种锁机制来控制多个线程对共享资源的互斥访问，第一个是 JVM 实现的 synchronized，而另一个是 JDK 实现的 ReentrantLock。

synchronized

同步一个代码块

public void func() {
    synchronized (this) {
        // ...
    }
}

当使用ExecutorService执行两个线程时，如果这两个线程调用的是同一个对象的同步代码块，那么它们将会进行同步操作。在这种情况下，当一个线程进入同步代码块时，另一个线程必须等待。

然而，如果这两个线程调用的是不同对象的同步代码块，那么它们将不会进行同步操作。因为同步代码块是以对象为单位进行加锁的，不同对象的同步代码块之间是相互独立的。这意味着一个线程可以进入一个对象的同步代码块，而另一个线程可以同时进入另一个对象的同步代码块，它们之间没有互斥关系。

因此，要实现多个线程之间的同步，确保正确的互斥性，需要使用同步块时，必须保证这些线程操作的是同一个对象，或者使用类级别的锁来进行同步，以确保线程之间的正确互斥行为。

public class SynchronizedExample {
    public void func1() {
        synchronized (this) {
            for (int i = 0; i < 10; i++) {
                System.out.print(i + " ");
            }
        }
    }
}

public static void main(String[] args) {
    SynchronizedExample e1 = new SynchronizedExample();
    ExecutorService executorService = Executors.newCachedThreadPool();
    executorService.execute(() -> e1.func1());
    executorService.execute(() -> e1.func1());
}

结果输出：0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9

对于以下代码，两个线程调用了不同对象的同步代码块，因此这两个线程就不需要同步。从输出结果可以看出，两个线程交叉执行。

public static void main(String[] args) {
    SynchronizedExample e1 = new SynchronizedExample();
    SynchronizedExample e2 = new SynchronizedExample();
    ExecutorService executorService = Executors.newCachedThreadPool();
    executorService.execute(() -> e1.func1());
    executorService.execute(() -> e2.func1());
}

结果输出0 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9

同步一个方法

public synchronized void func () {
    // ...
}

它和同步代码块一样，作用于同一个对象。
3. 同步一个类

public void func() {
    synchronized (SynchronizedExample.class) {
        // ...
    }
}

作用于整个类，也就是说两个线程调用同一个类的不同对象上的这种同步语句，也会进行同步。

public class SynchronizedExample {

    public void func2() {
        synchronized (SynchronizedExample.class) {
            for (int i = 0; i < 10; i++) {
                System.out.print(i + " ");
            }
        }
    }
}

public static void main(String[] args) {
    SynchronizedExample e1 = new SynchronizedExample();
    SynchronizedExample e2 = new SynchronizedExample();
    ExecutorService executorService = Executors.newCachedThreadPool();
    executorService.execute(() -> e1.func2());
    executorService.execute(() -> e2.func2());
}

0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9

同步一个静态方法

public synchronized static void fun() {
    // ...
}

作用于整个类。

ReentrantLock

ReentrantLock 是 java.util.concurrent(J.U.C)包中的锁。

public class LockExample {
    private Lock lock = new ReentrantLock();
    public void func() {
        lock.lock();
        try {
            for (int i = 0; i < 10; i++) {
                System.out.print(i + " ");
            }
        } finally {
            lock.unlock(); // 确保释放锁，从而避免发生死锁。
        }
    }
}

public static void main(String[] args) {
    LockExample lockExample = new LockExample();
    ExecutorService executorService = Executors.newCachedThreadPool();
    executorService.execute(() -> lockExample.func());
    executorService.execute(() -> lockExample.func());
}

结果输出：0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9

比较

锁的实现
synchronized 是 JVM 实现的，而 ReentrantLock 是 JDK 实现的。
性能
新版本 Java 对 synchronized 进行了很多优化，例如自旋锁等，synchronized 与 ReentrantLock 大致相同。
等待可中断
当持有锁的线程长期不释放锁的时候，正在等待的线程可以选择放弃等待，改为处理其他事情。
ReentrantLock 可中断，而 synchronized 不行。
公平锁
公平锁是指多个线程在等待同一个锁时，必须按照申请锁的时间顺序来依次获得锁。
synchronized 中的锁是非公平的，ReentrantLock 默认情况下也是非公平的，但是也可以是公平的。
锁绑定多个条件
一个 ReentrantLock 可以同时绑定多个 Condition 对象。Condition接口是与Lock相关联的条件队列，它提供了更灵活的线程等待和唤醒机制。通过ReentrantLock的newCondition()方法可以创建多个Condition对象，每个Condition对象可以用来管理特定的线程等待和唤醒。
使用多个Condition对象可以提供更细粒度的线程管理。例如，可以根据不同的条件将线程分组等待，在某个条件满足时只唤醒特定分组的线程。这样可以提高程序的运行效率，更好地控制线程的执行顺序和并发性。
在使用ReentrantLock和Condition时，通常的做法是在加锁的情况下，通过Condition对象的await()方法使线程等待，在满足条件时通过signal()或signalAll()方法唤醒等待线程

使用选择

在多线程编程中，synchronized关键字和ReentrantLock类都用于实现线程同步，但它们在使用方式和功能上有一些不同，选择取决于具体的需求和场景。

synchronized是Java中的关键字，它可以修饰方法或代码块，实现对共享资源的互斥访问。当一个线程获取到某个对象的锁时，其他线程需要等待，直到该线程释放锁。synchronized关键字的使用简单，不需要显式地释放锁，编译器和JVM会自动完成。然而，在某些情况下，synchronized的性能可能较低，因为它只提供了一种粗粒度的锁，并且无法中断一个正在等待锁的线程。

相比之下，ReentrantLock是一个独立的类，提供了更多高级的功能。它可以实现公平锁或非公平锁，支持多个条件等待，可以中断等待锁的线程，以及尝试获取锁的超时控制。ReentrantLock提供了更细粒度的锁控制，能够灵活地控制线程的获取和释放锁的顺序。它也提供了显式的获取和释放锁的方法，需要开发人员手动管理锁的状态。

选择使用synchronized关键字还是ReentrantLock取决于具体需求。如果只是简单的同步需求，使用synchronized可能更方便和高效。但如果需要更高级的功能，比如可中断锁、公平性、多条件等待等，以及更精细的锁控制，那么ReentrantLock会更适合。但需要注意，ReentrantLock的使用稍微复杂一些，需要开发人员显式地处理锁的获取和释放，避免出现死锁等问题。

在Java 5之后，ReentrantLock逐渐成为了一个更加强大和灵活的选择，但对于简单的同步需求，synchronized关键字仍然是一个便捷的选择。根据具体情况，开发人员可以根据需求选择合适的同步方案。