2.Lock锁

感谢秦疆老师的JUC并发编程视频，更多了解哔哩哔哩搜索【狂神说Java】。

本文内容源于秦疆老师的JUC并发编程视频教程。给狂神推荐，点赞吧！

传统的 synchronized 锁

package demo1;

/**
 * 基本的卖票例子
 * 线程就是一个单独的资源类，没有任何附属的操作
 * 1.属性 ，方法
 */
public class SaleTicketTest1 {


    public static void main(String[] args) {


        //并发 ：多线程操作同一个资源类 ，把资源丢入线程
        Ticket ticket = new Ticket();

        // @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();
    }

}

//资源类 oop
class Ticket {

    //属性 方法
    private int number = 30;

    //卖票的方式
    //synchronized 本质：队列 ，锁
    public synchronized void sale() {
        if (number > 0) {
            System.out.println(Thread.currentThread().getName() + "卖出了1张票，剩余" + (--number) + "张票！");
        }
    }

}

Lock接口

package demo1;

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

/**
 * 基本的卖票例子
 * 线程就是一个单独的资源类，没有任何附属的操作
 * 1.属性 ，方法
 */
public class SaleTicketLockTest {


    public static void main(String[] args) {


        //并发 ：多线程操作同一个资源类 ，把资源丢入线程
        TicketLock ticket = new TicketLock();

        // @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();

    }

}

//资源类 oop

/**
 * Lock三部曲
 * 1. new ReentrantLock();
 * 2.lock.lock()//加锁
 * 3.finally -> lock.unlock()//解锁
 */
class TicketLock {

    //属性 方法
    private int number = 30;

    Lock lock = new ReentrantLock();

    //卖票的方式
    public void sale() {


        //加锁
        lock.lock();
        try {
            //业务代码
            if (number > 0) {
                System.out.println(Thread.currentThread().getName() + "卖出了1张票，剩余" + (--number) + "张票！");
            }
        } finally {
            //解锁
            lock.unlock();
        }

    }

}

使用：

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

所有已知实现类：

• ReentrantLock 可重入锁（常用）
• ReentrantReadWriteLock.ReadLock 读锁
• ReentrantReadWriteLock.WriteLock 写锁

公平锁和非公平锁

公平锁：十分公平 ，可以先来后到

非公平锁：十分不公平，可以插队（默认非公平锁）

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(); //公平锁 new FairSync()
}

synchronized和 Lock的区别

1. synchronized内置的java关键字；Lock是一个Java类
2. synchronized无法判断获取锁的状态；Lock可以判断是否获取到了锁
3. synchronized 会自动释放锁；Lock 必须要手动释放锁！如果不释放锁，会死锁！
4. synchronized 线程1（获得锁，阻塞）、线程2（等待，傻傻的等待）；Lock不一定会等待下去；
5. synchronized 可重入锁，不可以中断的，非公平的；Lock,可重入锁，可以判断锁，非公平（可以自己设置）；
6. synchronized 适合锁少量的代码同步的问题；Lock适合大量的同步代码！

锁是什么？如何判断锁的是谁？

关于锁的八个问题：8锁现象