2.Lock锁（重点）

2.Lock锁（重点）

传统synchronized

//真正的多线程开发，公司中的开发，要降低耦合性
//线程就是一个单独的资源类，没有任何附属操作(所以使用Lambda表达式)
// 1.属性、方法

代码实现

public class SaleTicketDemo01 {
    public static void main(String[] args) {
        //并发：多线程操作同一个资源类，把资源丢入线程
        Ticket ticket = new Ticket();
        //@FunctionalInterface 函数式接口，jdk1.8，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();
    }
}


//此类没有继承Runnable接口是遵循OOP原则，如果继承了接口耦合性就会大大提升
//资源类：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默认为非公平锁，可以手动设置参数变为公平锁

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

public class SaleTicketDemo02 {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();
        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();
    }
}

//lock三部曲
//1.new ReentrantLock()
//2.lock.lock();//加锁
//3.finally-->lock.unlock();//解锁
class Ticket2{
    //属性、方法
    private int number = 50;
    public   void sale(){
        ReentrantLock lock = new ReentrantLock();
        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类

2.synchronized 无法判断获取锁的状态，Lock 可以判断是否获取到了锁

3.synchronized 会自动释放锁，lock 必须手动释放锁！如果不释放锁，死锁

4.synchronized 线程1（获得锁，阻塞）、线程2（等待，傻傻的等） lock 锁就不一定会一直等待下去

5.synchronized 可重入锁，不可以中断的，非公平； lock ，可重入锁，可以判断锁，非公平（可以自己设置）

**

4.synchronized 线程1（获得锁，阻塞）、线程2（等待，傻傻的等） lock 锁就不一定会一直等待下去

5.synchronized 可重入锁，不可以中断的，非公平； lock ，可重入锁，可以判断锁，非公平（可以自己设置）

6.synchronized 适合锁少量的代码同步问题，lock 适合锁大量的同步代码！