Lock锁

传统Synchronized

//基本卖票例子
/*
* 真正的多线程开发
* 线程就是一个单独的资源类，没有任何附属的操作，拿来即用
* 1. 属性，方法*/
public class SaleTicketDemo01 {
    public static void main(String[] args) {
        //多个线程操作同一资源类,资源类丢入线程
        Ticket ticket=new Ticket();
        //@FunctionalInterface 函数式接口，lambda表达式创建接口对象
        new Thread(()->{
            for (int i = 0; i < 60; i++) {
                ticket.sale();
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 60; i++) {
                ticket.sale();
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 60; i++) {
                ticket.sale();
            }
        },"C").start();
    }
}
//资源类 OOP 降低耦合性（不能实现Runnable接口）
class Ticket{
    //属性，方法
    private int number=50;
    //卖票的方式
    public synchronized void sale(){
        if(number>0){
            System.out.println(Thread.currentThread().getName()+"卖出了第"+number--+"张票");
        }
    }
}

Lock锁

公平锁：十分公平，先来后到，必须排队
非公平锁：十分不公平，可以插队（默认）

class Ticket{
    //属性，方法
    private int number=50;

    Lock lock=new ReentrantLock();
    //卖票的方式
    public void sale(){
        lock.lock();//加锁
        try{
            //业务代码
            if(number>0){
                System.out.println(Thread.currentThread().getName()+"卖出了第"+number--+"张票");
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            //解锁
            lock.unlock();
        }
    }
}

//lock锁三部曲
/*
* 1. new lock
* 2. lock.lock()加锁
* 3. finally解锁*/

lock锁和Synchronized区别

1. synchronized内置java关键字，lock是一个java类
2. synchronized无法判断获取锁，lock是可以判断是否获取到了锁
3. synchronized会自动释放锁，lock锁必须要手动释放锁（如果不释放会死锁）
4. synchronized线程一（获得锁，阻塞），线程二（等待，一直等待线程一释放锁）；lock就不一定会一直等待（lock.tryLock()尝试获取锁）
5. synchronized可重入锁，不可以中断的非公平锁；Lock，可重入锁，可以判断锁，非公平（可以自己设置）
6. synchronized适合锁少量的代码同步问题，Lock锁适合锁大量的同步代码
7. synchronized可以锁方法和代码块，Lock锁只能锁代码块