【JAVA】萌新必入！手把手教你玩转 Synchronized 锁和 Lock 锁！

sidiot

发布于 2023-08-31 13:11:11

7470

发布于 2023-08-31 13:11:11

文章被收录于专栏：技术大杂烩

前言

这是一篇关于 Synchronized 锁和 Lock 锁的超详细的万字博文，博文中列举了大量的例子用于理解，相信深度阅读本博文后，玩转 Synchronized 锁和 Lock 锁轻轻松松，有手就行！

Synchronized锁

synchronized 锁，传统的队列锁；

sychronized 的作用：在并发编程中会存在线程安全问题，主要原因是存在共享数据和多线程共同操作共享数据。关键字 sychronized 可以保证在同一时刻只有一个线程可以执行某个方法或某个代码块（临界区），同时 synchronized 可以保证一个线程的变化可见。只有共享资源读写访问才需要同步化，如果不是共享资源就没有必要同步。
三种应用方式：

修饰实例方法，对当前实例进行加锁，进入同步代码前需获得当前实例的锁；

修饰静态方法，对类对象加锁，要先获得当前类对象的锁；

修饰代码块，指定加锁对象，对给定对象加锁，要先获得给定对象的锁；

2.1 同步方法（静态方法、实例方法）：

用 sychronized 修饰的方法就叫做同步方法，保证 A 线程执行该方法的时候，其他线程只能在方法外等着。

synchronized public void doWorlk(){
     ...
}

对于非静态类方法，同步锁就是 this(实例对象)；

对于静态类方法，同步锁是当前方法所在类的字节码对象（类对象）；

2.2 同步代码块：

syschronized(同步锁){
  ....
}

同步锁：在任何时候最多只能有一个线程有同步锁，其他线程只能在代码块外等着。

为保证每个线程都能正常执行原子操作，Java 引入了线程同步机制。Java 程序运行可以使用任何对象作为同步监听对象，但一般把当前并发访问的共同资源作为同步监听对象。

举例子：

package com.idiot.demo1;

public class Test1 {
    public static void main(String[] args) throws InterruptedException {
        // 并发：多线程操作同一个资源类,
        Ticket ticket = new Ticket();
        // @FunctionalInterface 函数式接口
        new Thread(() -> {
            for (int i = 1; i < 20; i++) {
                //把资源类丢入线程
                ticket.sale();
            }
        }, "A").start();
        new Thread(() -> {
            for (int i = 1; i < 20; i++) {
                ticket.sale();
            }
        }, "B").start();
        new Thread(() -> {
            for (int i = 1; i < 20; i++) {
                ticket.sale();
            }
        }, "C").start();
    }
}

class Ticket {
    //共卖30张票
    private int number = 30;

    // 卖票的方式
    public synchronized void sale() {
        if (number > 0) {
            System.out.println(Thread.currentThread().getName() + "卖出了第" + (number--) + "票,剩余：" + number);
        }
    }
}

当多个线程同时对一个对象的一个方法进行操作，只有一个线程能够抢到锁。因为一个对象只有一把锁，一个线程获取了该对象的锁之后，其他线程无法获取该对象的锁，就不能访问该对象的其他 synchronized 实例方法，但是可以访问非 synchronized 修饰的方法。

Lock锁

Lock 锁是一个接口，其所有的实现类为

ReentrantLock (可重入锁)；
ReentrantReadWriteLock.ReadLock (可重入读写锁的读锁)；
ReentrantReadWriteLock.WriteLock (可重入读写锁的写锁)；

Lock 锁提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。Lock 接口的实现允许锁在不同的作用范围内获取和释放，并允许以任何顺序获取和释放多个锁。随着灵活的增加，也带来了更多的责任。不使用块结构锁就失去了使用 synchronized 方法和语句时会出现的锁自动释放功能。在大多数情况下，应使用以下语句：

Lock l = ...;
     l.lock();//加锁
     try {
         // access the resource protected by this lock
     } finally {
         l.unlock();//解锁
     }

加锁和解锁出现在不同作用范围中是，需谨慎确保锁定是所执行的所有代码用 try-finall 或 try-catch 保护，以确保在必要时释放锁。

公平锁：十分公平，必须先来后到；
非公平锁：十分不公平，可以插队；(默认为非公平锁)
可重入锁：如果锁具备可重入性，则称为可（可以）重（再次）入(进入同步域，即同步代码块/方法)锁(同步锁)。可重入就是指某个线程已经获得某个锁，可以再次获取相同的锁而不会出现死锁。

package com.idiot.demo1;

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

public class LockDemo {
    public static void main(String[] args) {
        final Ticket2 ticket = new Ticket2();

        new Thread(() -> {
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        }, "A").start();
        new Thread(() -> {
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        }, "B").start();
        new Thread(() -> {
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        }, "C").start();
    }
}
//lock三部曲
//1、    Lock lock=new ReentrantLock();
//2、    lock.lock() 加锁
//3、    finally=> 解锁：lock.unlock();
class Ticket2 {
    private int number = 30;

    // 创建锁
    Lock lock = new ReentrantLock();
    //卖票的方式
    public void sale() {
        lock.lock(); // 开启锁
        try {
            if (number > 0) {
                System.out.println(Thread.currentThread().getName() + "卖出了第" + (number--) + "张票剩余" + number + "张票");
            }
        }finally {
            lock.unlock(); // 关闭锁
        }

    }
}

Synchronized与Lock区别

1、Synchronized 内置的 Java 关键字；Lock 是一个 Java 类；

2、Synchronized 无法判断获取锁的状态；Lock 可以判断；

3、Synchronized 会自动释放锁；Lock 必须要手动加锁和手动释放锁，可能会遇到死锁；

4、Synchronized 线程1(获得锁->阻塞)、线程2(等待)；Lock 就不一定会一直等待下去，Lock 会有一个 trylock 去尝试获取锁，不会造成长久的等待；

5、Synchronized 是可重入锁，不可以中断的，非公平的；Lock，可重入的，可以判断锁，可以自己设置公平锁和非公平锁；

6、Synchronized 适合锁少量的代码同步问题，Lock 适合锁大量的同步代码；

生产者与消费者问题

面试题：单例模式，排序算法，生产者和消费者，死锁；

Synchronized

package com.idiot.demo1;

public class A {
    public static void main(String[] args) {
        Data data = new Data();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();


        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
    }
}

// 判断等待，业务，通知
class Data { // 数字 资源类
    private int number = 0;

    //+1
    public synchronized void increment() throws InterruptedException {
        if (number != 0) {    //0
            // 等待
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName() + "=>" + number);
        // 通知其他线程，我+1完毕了
        this.notifyAll();
    }

    //-1
    public synchronized void decrement() throws InterruptedException {
        if (number == 0) { // 1
            // 等待
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName() + "=>" + number);
        // 通知其他线程，我-1完毕了
        this.notifyAll();
    }
}

思考：如果有A，B，C，D四个线程，会出现什么情况？

会出现虚假唤醒问题，即除了输出0,1，还会有其他输出；

尝试之后的运行结果：

只需要将 if 改为 while 即可：

package com.idiot.demo1;

public class A {
    public static void main(String[] args) {
        Data data = new Data();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();


        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();


        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"D").start();
    }
}

// 判断等待，业务，通知
class Data { // 数字 资源类
    private int number = 0;

    //+1
    public synchronized void increment() throws InterruptedException {
        while (number != 0) {    //0
            // 等待
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName() + "=>" + number);
        // 通知其他线程，我+1完毕了
        this.notifyAll();
    }

    //-1
    public synchronized void decrement() throws InterruptedException {
        while (number == 0) { // 1
            // 等待
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName() + "=>" + number);
        // 通知其他线程，我-1完毕了
        this.notifyAll();
    }
}

Lock

通过 Lock 找到 Condition：

package com.idiot.demo1;

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

public class B {
    public static void main(String[] args) {
        Data2 data = new Data2();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();


        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();


        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"D").start();
    }
}

// 判断等待，业务，通知
class Data2 { // 数字 资源类
    private int number = 0;

    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();

    //condition.await();      等待
    //condition.signalAll();  唤醒全部
    //+1
    public void increment() throws InterruptedException {
        lock.lock();
        try {
            while (number != 0) {    //0
                condition.await();
            }
            number++;
            System.out.println(Thread.currentThread().getName() + "=>" + number);
            condition.signalAll();
        } catch (Exception e){
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    //-1
    public void decrement() throws InterruptedException {
        lock.lock();
        try {
            while (number == 0) {    //0
                condition.await();
            }
            number--;
            System.out.println(Thread.currentThread().getName() + "=>" + number);
            condition.signalAll();
        } catch (Exception e){
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

任何一个新的技术，绝对不是仅仅只是覆盖了原来的技术，更有优势和补充！Condition 精准的通知和唤醒线程；

可以从上面的运行截图中发现，A，B，C，D的输出是随机的，并不是我们想要的有序输出，这是就要使用 Condition 的精准通知和唤醒功能了；

package com.idiot.demo1;

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

public class C {
    public static void main(String[] args) {
        Data3 data = new Data3();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.printA();
            }
        },"A").start();


        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.printB();
            }
        },"B").start();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.printC();
            }
        },"C").start();
    }
}

class Data3{ // 资源类 Lock
    private int number = 1; // 1A 2B 3C

    private Lock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();

    public void printA(){
        lock.lock();
        try {
            while (number!=1){
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>A");
            number = 2;
            condition2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void printB(){
        lock.lock();
        try {
            while (number!=2){
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>B");
            number = 3;
            condition3.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void printC(){
        lock.lock();
        try {
            while (number!=3){
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>C");
            number = 1;
            condition1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

8锁现象

深刻理解锁，判断锁的是谁；

可以把锁理解为上厕所，两个方法一把锁，就好比只有一个厕所，里面已经有人在上了，且把门锁了，那么另一个人只能在门外等里面的人上完解锁出来，才能进去上厕所；

8锁，就是关于锁的8个问题：

1、标准情况下，两个线程先打印“发短信”还是“打电话”？

package com.idiot.lock8;

public class Test1 {
    public static void main(String[] args) {
        Phone phone = new Phone();

        new Thread(()->{
            phone.send();
        },"A").start();

        try {
            TimeUnit.SECONDS.sleep(1); 
        } catch (InterruptedException e) { 
            e.printStackTrace(); 
        }
        
        new Thread(()->{
            phone.call();
        },"B").start();
    }

}

class Phone{

    //synchronized 锁的对象是方法的调用者
    //两个方法用的是同一个锁，谁先拿到谁先执行！
    public synchronized  void send(){
        System.out.println("发短信");
    }

    public synchronized  void call(){
        System.out.println("打电话");
    }
}

运行结果：毋庸置疑的是发短信先输出，因为 send() 方法先拿到 synchronized 锁，call() 方法只能等 send() 执行完之后释放锁了，才能得到 synchronized 锁；

发短信
打电话

2、如果将 send() 方法内部延迟四秒，两个线程先打印“发短信”还是“打电话”？

public synchronized  void send(){
    try {
        TimeUnit.SECONDS.sleep(4);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("发短信");
}

运行结果：依然是发短信先输出，因为两个方法调用的是同一个对象，且 send() 方法先拿到 synchronized 锁，哪怕该方法内部睡眠了，也要等它执行完才能运行下一个线程，不会出现抢占的情况；

发短信
打电话

3、增加了一个普通方法后，先执行“发短信”还是 “hello”？

package com.idiot.lock8;

import java.util.concurrent.TimeUnit;

public class Test2 {
    public static void main(String[] args) {
        Phone2 phone = new Phone2();

        new Thread(()->{
            phone.send();
        },"A").start();

        try {
            TimeUnit.SECONDS.sleep(1); 
        } catch (InterruptedException e) { 
            e.printStackTrace(); 
        }
        
        new Thread(()->{
            phone.hello();
        },"B").start();
    }

}

class Phone2{

    //synchronized 锁的对象是方法的调用者
    public synchronized  void send(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    //不是同步方法，不受锁的影响
    public void hello(){
        System.out.println("hello");
    }
}

运行结果：hello 先输出，因为 hello() 只是一个普通方法，不受 synchronized 锁的影响，send() 方法睡眠的时候，hello() 方法借机抢占 CPU 或者说 CPU 自行调度使其先执行；

hello
发短信

4、两个对象，两个同步方法，先打印“发短信”还是“打电话”？

package com.idiot.lock8;

import java.util.concurrent.TimeUnit;

public class Test2 {
    public static void main(String[] args) {
        Phone2 phone1 = new Phone2();
        Phone2 phone2 = new Phone2();

        new Thread(()->{
            phone1.send();
        },"A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            phone2.call();
        },"B").start();
    }
}

class Phone2{

    //synchronized 锁的对象是方法的调用者
    public synchronized  void send(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public synchronized  void call(){
        System.out.println("打电话");
    }
}

运行结果：打电话先输出，因为是两个不同的对象，所以有两把 synchronized 锁，两把锁互不影响，send() 方法会睡眠4秒，因此“打电话”先输出；

打电话
发短信

5、增加两个静态的同步方法，只有一个对象，先打印“发短信”还是“打电话”？

package com.idiot.lock8;

import java.util.concurrent.TimeUnit;

public class Test3 {
    public static void main(String[] args) {
        Phone3 phone1 = new Phone3();

        new Thread(()->{
            phone1.send();
        },"A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            phone1.call();
        },"B").start();
    }
}

class Phone3{

    // static 静态方法,类一加载就有了,锁的是Class
    public static synchronized  void send(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public static synchronized  void call(){
        System.out.println("打电话");
    }
}

运行结果：发短信先输出，因为 static 静态方法在类加载的时候就有了，这意味着锁的不再是方法调用者了，而是 Class，因为是同一个对象，所以当 send() 方法获得 synchronized 锁之后，call() 方法只能等待；

发短信
打电话

6、增加两个静态的同步方法，有两个对象，先打印“发短信”还是“打电话”？

public static void main(String[] args) {
    Phone3 phone1 = new Phone3();
    Phone3 phone2 = new Phone3();

    new Thread(()->{
        phone1.send();
    },"A").start();

    try {
        TimeUnit.SECONDS.sleep(1);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

    new Thread(()->{
        phone2.call();
    },"B").start();
}

运行结果：发短信先输出，在第五实验时已经得出结论，有 static 时，锁的是 Class，因此，虽然是两个对象，但他们是同一个 Class 模板生成的，所以共用同一把锁；

发短信
打电话

如果创建一个跟 Phone3 一模一样的 Phone4，

Phone3 phone1 = new Phone3();
Phone4 phone2 = new Phone4();

运行结果：打电话先输出，因为两个对象是两把锁，互不影响，send() 方法又内置睡眠函数，因此 call() 方法先执行完；

打电话
发短信

7、1个静态的同步方法，1个普通的同步方法，一个对象，先打印“发短信”还是“打电话”？

package com.idiot.lock8;

import java.util.concurrent.TimeUnit;

public class Test4 {
    public static void main(String[] args) {
        Phone4 phone1 = new Phone4();

        new Thread(()->{
            phone1.send();
        },"A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            phone1.call();
        },"B").start();
    }
}

class Phone4{

    // static 静态方法,类一加载就有了,锁的是Class
    public static synchronized  void send(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public synchronized  void call(){
        System.out.println("打电话");
    }
}

运行结果：打电话先输出，静态方法锁的是 Class，而普通方法锁的是方法的调用者，两者不是同一把锁，因此互不影响；

打电话
发短信

8、1个静态的同步方法，1个普通的同步方法，两个对象，先打印“发短信”还是“打电话”？

public static void main(String[] args) {
    Phone4 phone1 = new Phone4();
    Phone4 phone2 = new Phone4();

    new Thread(()->{
        phone1.send();
    },"A").start();

    try {
        TimeUnit.SECONDS.sleep(1);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

    new Thread(()->{
        phone2.call();
    },"B").start();
}

运行结果：打电话先输出，在第七实验的时候，同一个对象的情况两者锁的都不是同一把锁，更何况两个对象呢；