JUC（2）Lock锁与Synchronized（重点）

Synchronized与Lock详解

最新推荐文章于 2022-09-11 17:56:39 发布

原创最新推荐文章于 2022-09-11 17:56:39 发布 · 217 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#Lock #synchronized

多线程与并发编程专栏收录该内容

38 篇文章

订阅专栏

本文对比分析了Synchronized关键字与Lock接口在Java并发编程中的应用。详细解释了两者的不同之处，包括锁的获取与释放机制、公平锁与非公平锁的区别等。并通过买票案例演示了它们的具体实现。

文章目录

一、传统的Synchronized （关键字）

一个买票案例

package com.wlw.demo01;
/**
 * 真正的多线程开发
 * 线程就是一个单独的资源类，没有任何的附属操作！ (只有属性和方法)
 */
public class SaleTicketDemo01 {
    public static void main(String[] args) {
        //多线程操作
        //并发：多线程操作同一个资源类，把资源类丢入线程
        final Ticket ticket = new Ticket();

        //@FunctionalInterface 函数式接口 jdk1.8之后 可用lambda表达式来代替
        new Thread(new Runnable() {
            public void run() {
                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();
    }
}
//资源类
//属性+方法
//oop
class Ticket{
    private int number = 50;
    //synchronized的本质就是将多个线程放进一个队列，并对共享的资源加锁，之后获得锁的线程才能使用这个资源
    public synchronized void sale(){
        if(number > 0){
            System.out.println(Thread.currentThread().getName()+"卖了第"+(number--)+"张票,"+"还剩"+number);
        }
    }
}

二、lock锁（lock是一个接口）

在这里插入图片描述

2.1 ReentrantLock 可重入锁中的公平锁与非公平锁

```
Lock lock = new ReentrantLock();
```
点进去看一下源码

/**
 * Creates an instance of {@code ReentrantLock}.
 * This is equivalent to using {@code ReentrantLock(false)}.
 */
public ReentrantLock() {
    sync = new NonfairSync(); //非公平锁
}

/**
 * Creates an instance of {@code ReentrantLock} with the
 * given fairness policy.
 *
 * @param fair {@code true} if this lock should use a fair ordering policy
 */
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync(); //FairSync()为公平锁
}

非公平锁： 十分不公平，可以插队；(默认为非公平锁) （这个可以保证运行时间短的线程先执行完，不用一直等待前面的需要很多时间才能执行完的线程）
公平锁： 十分公平，必须先来后到（严格按照先来后到的顺序执行）；

2.2与Synchronized不同的加锁方式的买票案例（Lock锁）

lock锁三部曲
- 1、 Lock lock=new ReentrantLock(); 创建锁
- 2、 lock.lock() 加锁
- 3、 finally块中解锁：lock.unlock();

package com.wlw.demo01;

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

/**
 * SaleTicketDemo01 用的是synchronized 关键字加锁，SaleTicketDemo02用lock锁
 */
public class SaleTicketDemo02 {
    public static void main(String[] args) {
        //多线程操作
        //并发：多线程操作同一个资源类，把资源类丢入线程
        Ticket2 ticket = new Ticket2();

        //@FunctionalInterface 函数式接口 jdk1.8之后 可用lambda表达式来代替
        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 = 50;

    Lock lock = new ReentrantLock(); //创建一个可重入锁

    public void sale(){
        lock.lock(); //加锁

        try {
            //业务代码
            if(number > 0){
                System.out.println(Thread.currentThread().getName()+"卖了第"+(number--)+"张票,"+"还剩"+number);
            }
        } catch (Exception e){
            e.printStackTrace();
        }
        finally {
            lock.unlock(); //解锁
        }
    }
}

三、Synchronized 和 Lock区别

1、Synchronized 内置的Java关键字，Lock是一个Java接口（在jvm层面，Lock是个java类）
2、Synchronized 无法判断获取锁的状态，Lock可以判断是否获取到锁；
3、Synchronized 会自动释放锁（a 线程执行完同步代码会释放锁；b 线程执行过程中发生异常会释放锁），lock必须要手动加锁和手动释放锁！（unlock()方法释放锁，否则容易造成线程死锁；）
4、用synchronized关键字的两个线程1和线程2，如果当前线程1获得锁，线程2线程等待。如果线程1阻塞，线程2则会一直等待下去， lock就不一定会一直等待下去，lock会有一个trylock去尝试获取锁，不会造成长久的等待，如果尝试获取不到锁，线程可以不用一直等待就结束了；
5、Synchronized 是可重入锁，不可以中断的，默认就是非公平的；Lock，可重入的，可以判断锁，可以自己设置公平锁和非公平锁（默认是非公平的，如果创建可重入锁时加了true就是获得公平锁）；
6、Synchronized 适合锁少量的代码同步问题，Lock适合锁大量的同步代码；