Java多线程锁

贼爱学习的小黄

已于 2023-07-26 14:39:31 修改

阅读量430

点赞数

分类专栏：小黄重学JUC 文章标签： java

于 2023-07-26 14:38:24 首次发布

本文链接：https://blog.csdn.net/yellow_star___/article/details/131938826

版权

小黄重学JUC 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

多线程锁

本专栏学习内容又是来自尚硅谷周阳老师的视频

有兴趣的小伙伴可以点击视频地址观看

Synchronized

Synchronized是Java中锁的一种实现方法，我们需要了解他锁在什么地方，锁的类型有哪些

阿里巴巴开发手册规定：

高并发时，同步调用应该去考量锁的性能消耗，能用无锁数据结构，就不要用锁；能锁区块，就不要锁整个方法体；能用对象锁，就不要用类锁

说明：尽可能使加锁的代码块工作量尽可能的小，避免在锁代码块中调用RPC方法

同步方法

操控两个线程、一个资源类

资源类

class Phone{
    public synchronized void sendEmail(){
        try {TimeUnit.MILLISECONDS.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}
        System.out.println("----sendEmail");
    }

    public synchronized void sendSMS(){
        System.out.println("----sendSMS");
    }

    public void hello(){
        System.out.println("hello");
    }
}

一个资源对象执行两个同步方法

线程A执行sendEmail()时会加锁，锁的对象是new Phone()也就是堆空间中的那个对象，在线程B调用sendSMS()时，锁对象也是new Phone()，所以需要等待线程A执行完毕才能获取锁

public class SyncDemo1 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        new Thread(() -> {
            phone.sendEmail();
        },"a").start();
        //保证线程a先运行
        TimeUnit.MILLISECONDS.sleep(200);
        new Thread(() -> {
            phone.sendSMS();
        },"b").start();
    }
}

//结果
----sendEmail
----sendSMS

一个资源对象执行一个同步方法和一个普通方法

这个就比较简单，因为hello()不需要获取锁，可以直接执行

public static void main(String[] args) throws InterruptedException {
    Phone phone = new Phone();
    new Thread(() -> {
        phone.sendEmail();
    },"a").start();
    //保证线程a先运行
    TimeUnit.MILLISECONDS.sleep(200);
    new Thread(() -> {
        phone.hello();
    },"b").start();
}

//结果
hello
----sendEmail

两个资源对象执行两个同步方法

因为这两个方法的锁对象不同，所以互不影响

public static void main(String[] args) throws InterruptedException {
    Phone phone = new Phone();
    Phone phone2 = new Phone();
    new Thread(() -> {
        phone.sendEmail();
    },"a").start();
    //保证线程a先运行
    TimeUnit.MILLISECONDS.sleep(200);
    new Thread(() -> {
        phone2.sendSMS();
    },"b").start();
}

//结果
----sendSMS
----sendEmail

静态同步方法

资源类

class Phone{
    public static synchronized void sendEmail(){
        try {TimeUnit.MILLISECONDS.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}
        System.out.println("----sendEmail");
    }

    public static synchronized void sendSMS(){
        System.out.println("----sendSMS");
    }

    public void hello(){
        System.out.println("hello");
    }
}

一个资源对象执行两个静态同步方法

对于静态同步方法，锁住的是Phone这个Class对象，也就是存在与方法区中的Phone，所以不管是一个资源对象还是多个资源对象，调用静态同步方法，使用的都是同一个锁

public static void main(String[] args) throws InterruptedException {
    Phone phone = new Phone();
    new Thread(() -> {
        phone.sendEmail();
    },"a").start();
    //保证线程a先运行
    TimeUnit.MILLISECONDS.sleep(200);
    new Thread(() -> {
        phone.sendSMS();
    },"b").start();
}

//结果
----sendEmail
----sendSMS

同步代码块

同步代码块的锁，就是括号中填的对象，可以是对象锁，也可以是类锁

synchronized (this) {
    
}

字节码角度分析

使用javap -c xxxx.class可以反编译字节码文件，如果要看详细信息可以使用javap -v xxxx.class

同步代码块

public class SyncDemo2 {
    Object object = new Object();

    public void m1() {
        synchronized (object) {
            System.out.println("m1 method");
        }
    }
    public static void main(String[] args) throws InterruptedException {

    }
}

在JVM中是由monitore来控制锁的，但是在同步代码块中，发现有一个获取锁，有两个释放锁

第二个释放锁有点保护机制的意思，如果同步代码块中出现异常，无法正常释放锁，会有异常的释放方式

同步方法和静态同步方法

    public synchronized void m2() {
        System.out.println("m2 method");
    }
    
    public static synchronized void m3() {
        System.out.println("m2 method");
    }

JVM中使用ACC_SYNCHRONIZED来表示当前方法是同步方法，使用ACC_STATIC来表示该方法为静态方法

公平锁、非公平锁

非公平锁

非公平锁是一种线程同步机制，它允许新的线程在获取锁时，不考虑其他等待线程的顺序，有可能插队获取到锁资源。相对于公平锁来说，非公平锁在一定程度上可以提高系统的吞吐量，但可能导致某些线程长时间地等待。

模拟卖票案例

一共50张票，交给a、b、c三个窗口去卖

public class LockDemo1 {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();
        new Thread(() -> {for(int i = 0;i < 60;i++) ticket.buy();},"a").start();
        new Thread(() -> {for(int i = 0;i < 60;i++) ticket.buy();},"b").start();
        new Thread(() -> {for(int i = 0;i < 60;i++) ticket.buy();},"c").start();
    }
}

class Ticket {
    private int sum = 50;
	//默认使用非公平锁
    private ReentrantLock lock = new ReentrantLock();

    public void buy() {
        try {
            lock.lock();
            if (sum > 0) {
                System.out.println(Thread.currentThread().getName() + "卖出第  " + sum + " 张票，还剩 " + --sum);
            }
        } finally {
            lock.unlock();
        }
    }
}

通过观察结果可以发现，可能有一个窗口把50张票卖完，也有可能一个窗口一张票都卖不出

公平锁

公平锁是一种线程同步机制，它按照线程请求锁的顺序来分配锁资源，保证线程获取锁的顺序与其请求锁的顺序一致。公平锁可以避免线程饥饿的情况，但可能降低系统的吞吐量。

模拟买票案例

可以使用new ReentrantLock(true)来创建公平锁，可以从结果看出，运行一段时间后会保证顺序获取锁

如何选择

一般来说，对于线程执行顺序要求不高的，完全可以使用非公平锁，因为线程之间的切换是非常消耗时间的，非公平锁可以提高吞吐量。

可重入锁

简单理解为：可以重复进入的同步锁，当然是有前提条件的

概念

可重入锁是一种线程同步机制，也称为递归锁。它允许同一个线程在拥有锁的情况下多次进入被锁定的代码块，而不会造成死锁。可重入锁在保证线程安全的同时，提供了更大的灵活性和方便性。

代码演示

synchronized和ReentrantLock都属于可重入锁

synchronized

如果不是可重入锁，按照同步锁的理论知识，外层获取object锁时，第二层应该就不能获取到该锁，程序应该会卡死在那里，但是我们发现程序正常的执行完毕，由此可见synchronized是可重入锁

public static void main(String[] args) throws InterruptedException {
    final Object object = new Object();
    synchronized (object) {
        System.out.println(Thread.currentThread().getName() + "进入外层");
        synchronized (object) {
            System.out.println(Thread.currentThread().getName() + "进入中层");
            synchronized (object) {
                System.out.println(Thread.currentThread().getName() + "进入内层");
            }
        }
    }
}

//结果
main进入外层
main进入中层
main进入内层

ReentrantLock

ReentrantLock锁对象是ReentrantLock类的实例，同样也是可重入锁

public static void main(String[] args) {
    ReentrantLock lock = new ReentrantLock();
    lock.lock();
    try {
        System.out.println(Thread.currentThread().getName() + "进入外层");
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "进入中层");
            lock.lock();
            try {
                System.out.println(Thread.currentThread().getName() + "进入内层");
            }finally {
                lock.unlock();
            }
        }finally {
            lock.unlock();
        }
    }finally {
        lock.unlock();
    }
}

//结果
main进入外层
main进入中层
main进入内层

原理

每一个锁对象拥有一个锁计数器和一个指向持有该锁的线程的指针

当执行monitorenter时，如果锁对象的计数器为0，那么说明他没有被其他线程所持有，JVM会将锁对象的持有线程设置为当前线程，并且将其计数器+1。

在目标锁的计数器不为0的情况下，如果锁对象的持有线程是当前线程，那么JVM可以将其计数器+1，否则需要等待。

当执行monitorexit时，JVM会将对象的计数器-1，计数器为0代表锁已经被释放。

死锁

死锁是多线程编程中一种常见的情况，指的是两个或多个线程无限期地等待对方释放资源，从而导致程序无法继续执行的状态。

public class SycnDemo04 {
    static Object a = new Object();
    static Object b = new Object();

    public static void main(String[] args) {
        new Thread(()->{
            synchronized (a){
                System.out.println(Thread.currentThread().getName() + "获取了锁a");
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (b){
                    System.out.println(Thread.currentThread().getName() + "获取了锁b");
                }
            }
        },"A").start();

        new Thread(()->{
            synchronized (b){
                System.out.println(Thread.currentThread().getName() + "获取了锁b");
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (a){
                    System.out.println(Thread.currentThread().getName() + "获取了锁a");
                }
            }
        },"B").start();
    }
}

//结果
A获取了锁a
B获取了锁b