关于后端:Java-中-synchronized-和-Lock-的区别与使用

39次阅读

共计 7160 个字符，预计需要花费 18 分钟才能阅读完成。

莫听穿林打叶声，何妨吟啸且徐行。

技术点：

1、线程与过程：

在开始之前先把过程与线程进行辨别一下，一个程序起码须要一个过程，而一个过程起码须要一个线程。关系是线程–> 过程–> 程序的大抵组成构造。所以线程是程序执行流的最小单位，而过程是零碎进行资源分配和调度的一个独立单位。以下咱们所有探讨的都是建设在线程根底之上。

2、Thread 的几个重要办法：

咱们先理解一下 Thread 的几个重要办法。

  • start() 办法，调用该办法开始执行该线程；
  • stop() 办法，调用该办法强制完结该线程执行；
  • join 办法，调用该办法期待该线程完结。
  • sleep() 办法，调用该办法该线程进入期待。
  • run() 办法，调用该办法间接执行线程的 run() 办法，然而线程调用 start() 办法时也会运行 run() 办法，区别就是一个是由线程调度运行 run() 办法，一个是间接调用了线程中的 run() 办法！！

看到这里，可能有些人就会问啦，那 wait() 和 notify() 呢？要留神，其实 wait() 与 notify() 办法是 Object 的办法，不是 Thread 的办法！！同时，wait() 与 notify() 会配合应用，别离示意线程挂起和线程复原。

这里还有一个很常见的问题，顺带提一下：wait() 与 sleep() 的区别，简略来说 wait() 会开释对象锁而 sleep() 不会开释对象锁。这些问题有很多的材料，不再赘述。

3、线程状态：


线程总共有 5 大状态，通过下面第二个知识点的介绍，了解起来就简略了。

  • 新建状态：新建线程对象，并没有调用 start() 办法之前
  • 就绪状态：调用 start() 办法之后线程就进入就绪状态，然而并不是说只有调用 start() 办法线程就马上变为以后线程，在变为以后线程之前都是为就绪状态。值得一提的是，线程在睡眠和挂起中复原的时候也会进入就绪状态哦。
  • 运行状态：线程被设置为以后线程，开始执行 run() 办法。就是线程进入运行状态
  • 阻塞状态：线程被暂停，比如说调用 sleep() 办法后线程就进入阻塞状态
  • 死亡状态：线程执行完结

4、锁类型

  • 可重入锁：在执行对象中所有同步办法不必再次取得锁
  • 可中断锁：在期待获取锁过程中可中断
  • 偏心锁：按期待获取锁的线程的等待时间进行获取，等待时间长的具备优先获取锁权力
  • 读写锁：对资源读取和写入的时候拆分为 2 局部解决，读的时候能够多线程一起读，写的时候必须同步地写

synchronized 与 Lock 的区别

1、我把两者的区别分类到了一个表中，不便大家比照：

或者，看到这里还对 LOCK 所知甚少，那么接下来，咱们进入 LOCK 的深刻学习。

Lock 具体介绍与 Demo

以下是 Lock 接口的源码，笔者修剪之后的后果：

public interface Lock {
    /**
     * Acquires the lock.
     */
    void lock();
    /**
     * Acquires the lock unless the current thread is
     * {@linkplain Thread#interrupt interrupted}.
     */
    void lockInterruptibly() throws InterruptedException;
    /**
     * Acquires the lock only if it is free at the time of invocation.
     */
    boolean tryLock();
    /**
     * Acquires the lock if it is free within the given waiting time and the
     * current thread has not been {@linkplain Thread#interrupt interrupted}.
     */
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
    /**
     * Releases the lock.
     */
    void unlock();}

从 Lock 接口中咱们能够看到次要有个办法，这些办法的性能从正文中能够看出：

  • lock()：获取锁，如果锁被暂用则始终期待
  • unlock()：开释锁
  • tryLock(): 留神返回类型是 boolean，如果获取锁的时候锁被占用就返回 false，否则返回 true
  • tryLock(long time, TimeUnit unit)：比起 tryLock() 就是给了一个工夫期限，保障期待参数工夫
  • lockInterruptibly()：用该锁的取得形式，如果线程在获取锁的阶段进入了期待，那么能够中断此线程，先去做别的事

通过 以上的解释，大抵能够解释在上个局部中“锁类型 (lockInterruptibly())”，“锁状态 (tryLock())”等问题，还有就是后面子所获取的过程我所写的“大抵就是能够尝试取得锁，线程能够不会始终期待”用了“能够”的起因。

上面是 Lock 个别应用的例子，留神 ReentrantLock 是 Lock 接口的实现。

lock()：

package com.malf;

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

public class LockTest {private Lock lock = new ReentrantLock();
    // 须要参加同步的办法
    private void method(Thread thread) {lock.lock();
        try {System.out.println("线程名" + thread.getName() + "取得了锁");
        } catch (Exception e) {e.printStackTrace();
        } finally {System.out.println("线程名" + thread.getName() + "开释了锁");
            lock.unlock();}
    }

    public static void main(String[] args) {LockTest lockTest = new LockTest();
        // 线程 1
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {lockTest.method(Thread.currentThread());
            }
        }, "t1");
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {lockTest.method(Thread.currentThread());
            }
        }, "t2");
        t1.start();
        t2.start();}
}
// 执行状况：线程名 t1 取得了锁
//         线程名 t1 开释了锁
//         线程名 t2 取得了锁
//         线程名 t2 开释了锁

tryLock():

package com.malf;

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

public class LockTest {private Lock lock = new ReentrantLock();
    // 须要参加同步的办法
    private void method(Thread thread) {/*lock.lock();
        try {System.out.println("线程名"+thread.getName() + "取得了锁");
        }catch(Exception e){e.printStackTrace();
        } finally {System.out.println("线程名"+thread.getName() + "开释了锁");
            lock.unlock();}*/
        if (lock.tryLock()) {
            try {System.out.println("线程名" + thread.getName() + "取得了锁");
            } catch (Exception e) {e.printStackTrace();
            } finally {System.out.println("线程名" + thread.getName() + "开释了锁");
                lock.unlock();}
        } else {System.out.println("我是" + Thread.currentThread().getName() + "有人占着锁，我就不要啦");
        }
    }

    public static void main(String[] args) {LockTest lockTest = new LockTest();
        // 线程 1
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {lockTest.method(Thread.currentThread());
            }
        }, "t1");
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {lockTest.method(Thread.currentThread());
            }
        }, "t2");
        t1.start();
        t2.start();}
}
// 执行后果：线程名 t2 取得了锁
//         我是 t1 有人占着锁，我就不要啦
//         线程名 t2 开释了锁

看到这里置信大家也都会应用如何应用 Lock 了吧，对于 tryLock(long time, TimeUnit unit) 和 lockInterruptibly() 不再赘述。前者次要存在一个等待时间，在测试代码中写入一个等待时间，后者次要是期待中断，会抛出一个中断异样，罕用度不高，喜爱探索能够本人深入研究。

后面比拟重提到“偏心锁”，在这里能够提一下 ReentrantLock 对于均衡锁的定义，在源码中有这么两段：

/**
 * Sync object for non-fair locks
 */
static final class NonfairSync extends Sync {
    private static final long serialVersionUID = 7316153563782823691L;
    /**
     * Performs lock.  Try immediate barge, backing up to normal
     * acquire on failure.
     */
    final void lock() {if (compareAndSetState(0, 1))
            setExclusiveOwnerThread(Thread.currentThread());
        else
            acquire(1);
    }

    protected final boolean tryAcquire(int acquires) {return nonfairTryAcquire(acquires);
    }
}
/**
 * Sync object for fair locks
 */
static final class FairSync extends Sync {
    private static final long serialVersionUID = -3000897897090466540L;

    final void lock() {acquire(1);
    }
    /**
     * Fair version of tryAcquire.  Don't grant access unless
     * recursive call or no waiters or is first.
     */
    protected final boolean tryAcquire(int acquires) {final Thread current = Thread.currentThread();
        int c = getState();
        if (c == 0) {if (!hasQueuedPredecessors() &&
                    compareAndSetState(0, acquires)) {setExclusiveOwnerThread(current);
                return true;
            }
        } else if (current == getExclusiveOwnerThread()) {
            int nextc = c + acquires;
            if (nextc < 0)
                throw new Error("Maximum lock count exceeded");
            setState(nextc);
            return true;
        }
        return false;
    }
}

从以上源码能够看出在 Lock 中能够本人管制锁是否偏心，而且，默认的是非偏心锁，以下是 ReentrantLock 的构造函数：

public ReentrantLock() {sync = new NonfairSync();// 默认非偏心锁
}

补充

1、两种锁的底层实现形式：

synchronized：咱们晓得 java 是用字节码指令来控制程序（这里不包含热点代码编译成机器码）。在字节指令中，存在有 synchronized 所蕴含的代码块，那么会造成 2 段流程的执行。

咱们点击查看 SyncDemo.java 的源码 SyncDemo.class，能够看到如下：

如上就是这段代码段字节码指令，没你想的那么难吧。言归正传，咱们能够清晰段看到，其实 synchronized 映射成字节码指令就是减少来两个指令：monitorenter 和 monitorexit。当一条线程进行执行的遇到 monitorenter 指令的时候，它会去尝试取得锁，如果取得锁那么锁计数 +1（为什么会加一呢，因为它是一个可重入锁，所以须要用这个锁计数判断锁的状况），如果没有取得锁，那么阻塞。当它遇到 monitorexit 的时候，锁计数器 -1，当计数器为 0，那么就开释锁。

那么有的敌人看到这里就纳闷了，那图上有 2 个 monitorexit 呀？马上答复这个问题：下面我以前写的文章也有表述过，synchronized 锁开释有两种机制，一种就是执行完开释；另外一种就是发送异样，虚拟机开释。图中第二个 monitorexit 就是产生异样时执行的流程，这就是我结尾说的“会有 2 个流程存在“。而且，从图中咱们也能够看到在第 13 行，有一个 goto 指令，也就是说如果失常运行完结会跳转到 19 行执行。

这下，你对 synchronized 是不是理解的很清晰了呢。接下来咱们再聊一聊 Lock。

Lock：Lock 实现和 synchronized 不一样，后者是一种乐观锁，它胆子很小，它很怕有人和它抢吃的，所以它每次吃货色前都把本人关起来。而 Lock 呢底层其实是 CAS 乐观锁的体现，它无所谓，他人抢了它吃的，它从新去拿吃的就好啦，所以它很乐观。具体底层怎么实现，博主不在细述，有机会的话，我会对 concurrent 包上面的机制好好和大家说说，如果面试问起，你就说底层次要靠 volatile 和 CAS 操作实现的。

当初，才是我真正想在这篇博文前面加的，我要说的是：尽可能去应用 synchronized 而不要去应用 LOCK

什么概念呢？我和大家打个比方：你叫 jdk，你生了一个孩子叫 synchronized，起初呢，你领养了一个孩子叫 LOCK。起初，LOCK 刚来到新家的时候，它很乖，很懂事，各个方面都体现的比 synchronized 好。你很开心，然而你内心深处又有一点淡淡的难过，你不心愿你本人亲生的孩子居然还不如一个领养的孩子灵巧。这个时候，你对亲生的孩子教育更加粗浅了，你想证实，你的亲生孩子 synchronized 并不会比领养的孩子 LOCK 差。（博主只是打个比方）

那如何教育呢？

在 jdk1.6~jdk1.7 的时候，也就是 synchronized16、7 岁的时候，你作为爸爸，你给他优化了，具体优化在哪里呢：

1、线程自旋和适应性自旋

咱们晓得，java’线程其实是映射在内核之上的，线程的挂起和复原会极大的影响开销。并且 jdk 官网人员发现，很多线程在期待锁的时候，在很短的一段时间就取得了锁，所以它们在线程期待的时候，并不需要把线程挂起，而是让他无目标的循环，个别设置 10 次。这样就防止了线程切换的开销，极大的晋升了性能。

而适应性自旋，是赋予了自旋一种学习能力，它并不固定自旋 10 次一下。他能够依据它后面线程的自旋状况，从而调整它的自旋，甚至是不通过自旋而间接挂起。

2、锁打消

什么叫锁打消呢？就是把不必要的同步在编译阶段进行移除。

那么有的小伙伴又迷糊了，我本人写的代码我会不晓得这里要不要加锁？我加了锁就是示意这边会有同步呀？

并不是这样，这里所说的锁打消并不一定指代是你写的代码的锁打消，我打一个比如：

在 jdk1.5 以前，咱们的 String 字符串拼接操作其实底层是 StringBuffer 来实现的（这个大家能够用我后面介绍的办法，写一个简略的 demo，而后查看 class 文件中的字节码指令就分明了），而在 jdk1.5 之后，那么是用 StringBuilder 来拼接的。咱们思考后面的状况，比方如下代码：

String str1="qwe";  
String str2="asd";  
String str3=str1+str2;

底层实现会变成这样：

StringBuffer sb = new StringBuffer();  
sb.append("qwe");  
sb.append("asd");

咱们晓得，StringBuffer 是一个线程平安的类，也就是说两个 append 办法都会同步，通过指针逃逸剖析（就是变量不会外泄），咱们发现在这段代码并不存在线程平安问题，这个时候就会把这个同步锁打消。

3、锁粗化

在用 synchronized 的时候，咱们都考究为了防止大开销，尽量同步代码块要小。那么为什么还要加粗呢？

咱们持续以下面的字符串拼接为例，咱们晓得在这一段代码中，每一个 append 都须要同步一次，那么我能够把锁粗化到第一个 append 和最初一个 append（这里不要去纠结后面的锁打消，我只是打个比方）

4、轻量级锁（略）

5、偏差锁（略）

正文完
后端
发表至： 后端
2020-08-18
 0
关于后端:解决WPS字体缺失问题的四种方法
关于后端:探索-Gateway-API-在-Service-Mesh-中的工作机制
关于后端:NettyNIO五多线程优化
Go-Modules-详解