Java 同步机制

最新推荐文章于 2024-10-05 10:30:24 发布

OOC_ZC

最新推荐文章于 2024-10-05 10:30:24 发布

阅读量731

点赞数 1

分类专栏： Java

本文链接：https://blog.csdn.net/OOC_ZC/article/details/84759458

版权

Java 专栏收录该内容

42 篇文章 0 订阅

订阅专栏

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

一、synchronized

JVM基于进入和退出Monitor对象来实现方法同步和代码块同步。
代码块同步是使用monitorenter和monitorexit指令实现的。
任何对象（数组也是对象）都有一个monitor与之关联，当一个monitor被持有后，对象将处于锁定状态。
线程执行到monitortenter指令时，将会尝试获取对象所对应的monitor的所有权，即尝试获得对象的锁。

1. 同步一个代码块

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

它只作用于同一个对象，如果调用两个对象上的同步代码块，就不会进行同步。

代码示例：

// 死锁示例 ：
public class Main {
    private static String a = "a";
    private static String b = "b";

    public static void main(String[] args) throws Exception {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (a) {
                    try{
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (b) {
                        System.out.println(a + b);
                    }
                }
            }
        });

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (b) {
                    try{
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (a) {
                        System.out.println(a + b);
                    }
                }
            }
        });
        t1.start();
        t2.start();
    }
}

2. 同步一个方法

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

它和同步代码块一样，作用于同一个对象。即如果此类有多个synchronized函数，则一个对象一个时间只有一个synchronized函数执行。即进入synchronized前需要获得对象锁。

同步方法示例：

public class SynchGenerator implements Runnable {
    private int i = 0;
    public synchronized int next() { // 输出均为偶数
    //public int next() {  //  输出有奇数
        ++i;
        Thread.yield();
        ++i;
        return i;
    }
    @Override
    public void run() {
        System.out.println(next());
    }
    public static void main(String[] args) {
        SynchGenerator s = new SynchGenerator();
        ExecutorService es = Executors.newCachedThreadPool();
        for (int i = 0; i < 100; ++i) {
        // 启动一百个线程执行s这个对象的next()方法
            es.execute(s); 
        }
        es.shutdown();
    }
}

对方法增加synchronized关键词后输出均为偶数，不加则有奇数输出。

3. 同步一个类

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

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

4. 同步一个静态方法

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

作用于整个类。

二、ReentrantLock (可重入锁)

ReentrantLock 是 java.util.concurrent（J.U.C）包中的锁。

ReentrantLock 是通过AQS(AbstractqueuedSynchronizer, 队列同步器)实现的，其中AQS的同步队列是基于双向链表的FIFO实现。

JDK中的Unsafe类，它提供了硬件级别的原子操作，即提供了CAS操作。多个线程同时进来，他们会首先会通过CAS去修改state变量的状态，修改成功的线程获得锁，其他线程入队。

tryLock() 尝试非阻塞的获取锁，调用后立刻返回true(可以获取锁)或者false。

ReentrantLock 代码示例：

public class LockExample {

    private Lock lock = new ReentrantLock();

    public void func() {
        lock.lock();  
        // lock()不要在try语句块中，因为如果出现异常到finally中无锁可以释放。
        try {
            for (int i = 0; i < 10; i++) {
                System.out.print(i + " ");
            }
        } finally {
            lock.unlock(); 
            // unlock() 放在finally中，确保释放锁，从而避免发生死锁。
        }
    }

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

三、synchronized和ReentrantLock比较

锁的实现： synchronized 是 JVM 实现的，而 ReentrantLock 是 JDK 实现的。
性能： 新版本 Java 对 synchronized 进行了很多优化，例如自旋锁等，synchronized 与 ReentrantLock 性能大致相同。
超时放弃： 当持有锁的线程长期不释放锁的时候，正在等待的线程可以选择放弃等待，改为处理其他事情。ReentrantLock 可中断等待，而 synchronized 不行。
等待可中断：ReenTrantLock提供了一种能够中断等待锁的线程的机制，通过lock.lockInterruptibly()来实现这个机制。而 synchronized 不行。
尝试非阻塞地获取锁：ReenTrantLock 通过 tryLock() 提供这个功能，如果当前锁没有线程获得则获得此锁，否则直接返回，不阻塞等待。
公平锁： 公平锁是指多个线程在等待同一个锁时，必须按照申请锁的时间顺序来依次获得锁。synchronized 中的锁是非公平的，ReentrantLock 默认情况下也是非公平的，但是也可以是公平的。ReentrantLock lock()获得锁的过程可以是公平的，但signal()唤醒的过程是随机的。
锁绑定多个条件： 一个 ReentrantLock 可以同时绑定多个 Condition 对象。 ReenTrantLock提供了一个Condition（条件）类，用来实现分组唤醒需要唤醒的线程们，而不是像synchronized要么随机唤醒一个线程要么唤醒全部线程。
可重入锁：也叫做递归锁，指的是在同一线程内，外层函数获得锁之后，内层递归函数仍然可以获取到该锁。ReentrantLock 和 synchronized 都是可重入锁。
使用选择： 除非需要使用 ReentrantLock 的高级功能，否则优先使用 synchronized。这是因为 synchronized 是 JVM 实现的一种锁机制，JVM 原生地支持它，而 ReentrantLock 不是所有的 JDK 版本都支持。并且使用 synchronized 不用担心没有释放锁而导致死锁问题，因为 JVM 会确保锁的释放。
解锁顺序：lock更灵活，可以自由定义多把锁的加锁解锁顺序，synchronized要按照先加的后解顺序。（在执行完synchronized块后自行解锁，所有会按照synchronized的嵌套顺序解锁。）