多线程锁

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

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

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