Lock锁

传统的Synchronized锁

线程就是一个单独的资源类，它没有任何的附属操作！
先看不加Synchronized多线程并发下的买票问题：

public class SaleTicket {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();
        //并发，多个线程操作同一个资源类，将类丢入线程。
        new Thread(()->{
                for (int i = 1; i < 40; i++){
                    ticket.sale();
                }
            },"A").start();

        new Thread(()->{
                for (int i = 1; i < 40; i++){
                    ticket.sale();
                }
            },"B").start();

        new Thread(()->{
                for (int i = 1; i < 40; i++){
                    ticket.sale();
                }
            },"C").start();
    }
}

class Ticket{
    /*票数*/
    private int number = 30;

    /*买票的方式*/
    public void sale(){
        if (number > 0){
            System.out.println(Thread.currentThread().getName()+"卖出了第"+(number--)+"张，还剩"+number+"张。");
        }

    }
}

运行结果：

A卖出了第30张，还剩29张。
A卖出了第29张，还剩28张。
A卖出了第28张，还剩27张。
A卖出了第27张，还剩26张。
A卖出了第26张，还剩25张。
A卖出了第25张，还剩24张。
A卖出了第24张，还剩23张。
A卖出了第23张，还剩22张。
A卖出了第22张，还剩21张。
A卖出了第21张，还剩20张。
A卖出了第20张，还剩19张。
A卖出了第19张，还剩18张。
A卖出了第18张，还剩17张。
C卖出了第16张，还剩15张。
C卖出了第15张，还剩14张。
C卖出了第14张，还剩13张。
C卖出了第13张，还剩12张。
C卖出了第12张，还剩11张。
C卖出了第11张，还剩10张。
C卖出了第10张，还剩9张。
C卖出了第9张，还剩8张。
C卖出了第8张，还剩7张。
C卖出了第7张，还剩6张。
C卖出了第6张，还剩5张。
C卖出了第5张，还剩4张。
C卖出了第4张，还剩3张。
C卖出了第3张，还剩2张。
C卖出了第2张，还剩1张。
C卖出了第1张，还剩0张。
B卖出了第17张，还剩16张。

Process finished with exit code 0

很明显可以看到，多个线程操作一个资源类的时候，会出现抢占的情况，导致运行结果不是我们想要看到的那样，所以为保证线程同步安全，传统方式我们会在资源类中加入Synchronized锁以达到我们保证线程同步安全的目的。

/**
     * synchronized 本质：队列、锁*/
    public synchronized void sale(){
        if (number > 0){
            System.out.println(Thread.currentThread().getName()+"卖出了第"+(number--)+"张，还剩"+number+"张。");
        }

    }

使用Synchronized锁后的运行结果：

A卖出了第30张，还剩29张。
A卖出了第29张，还剩28张。
A卖出了第28张，还剩27张。
A卖出了第27张，还剩26张。
A卖出了第26张，还剩25张。
A卖出了第25张，还剩24张。
A卖出了第24张，还剩23张。
A卖出了第23张，还剩22张。
A卖出了第22张，还剩21张。
A卖出了第21张，还剩20张。
A卖出了第20张，还剩19张。
A卖出了第19张，还剩18张。
A卖出了第18张，还剩17张。
A卖出了第17张，还剩16张。
A卖出了第16张，还剩15张。
A卖出了第15张，还剩14张。
A卖出了第14张，还剩13张。
A卖出了第13张，还剩12张。
A卖出了第12张，还剩11张。
A卖出了第11张，还剩10张。
B卖出了第10张，还剩9张。
B卖出了第9张，还剩8张。
B卖出了第8张，还剩7张。
B卖出了第7张，还剩6张。
B卖出了第6张，还剩5张。
B卖出了第5张，还剩4张。
B卖出了第4张，还剩3张。
B卖出了第3张，还剩2张。
B卖出了第2张，还剩1张。
B卖出了第1张，还剩0张。

Process finished with exit code 0

Lock锁

基本实现类，常用ReentrantLock可重入锁

ReentrantLock有两个构造方法，无参构造默认非公平锁，可以允许插队；有参构造可以传入一个Boolean值进行判断，若为true，则是公平锁，不允许插队，先来的先执行！

使用Lock锁的买票例子：

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

public class SaleTicket02 {
    public static void main(String[] args) {
        Ticket02 ticket = new Ticket02();
        //并发，多个线程操作同一个资源类，将类丢入线程。
        new Thread(()->{
                for (int i = 1; i < 40; i++){
                    ticket.sale();
                }
            },"A").start();

        new Thread(()->{
                for (int i = 1; i < 40; i++){
                    ticket.sale();
                }
            },"B").start();

        new Thread(()->{
                for (int i = 1; i < 40; i++){
                    ticket.sale();
                }
            },"C").start();
    }
}

/**
 * Lock三部曲
 * 1.new ReentrantLock()
 * 2.lock.lock() 加锁;
 * 3.finally ==> lock.unlock() 解锁*/
class Ticket02{
    /*票数*/
    private int number = 30;

    //Lock锁
    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的区别

• synchronized 是内置的Java关键字，Lock 是一个Java类。
• synchronized 无法判断获取锁的状态，Lock 可以判断是否获取到了锁。
• synchronized 会自动释放锁，Lock 必须要手动释放锁，若不释放锁，会死锁！
• synchronized 线程A（获得锁，阻塞），线程B（等待，一直等待）；Lock 不一定会等待下去，可以用lock.tryLock()尝试获取锁。
• synchronized 默认可重入，不可以中断的，非公平；Lock 默认可重入，可以进行判断锁，非公平（可以进行设置）。
• synchronized 适合锁少量的代码同步问题；Lock 适合锁大量的同步代码！