JUC并发编程学习（三）-Lock锁

多线程的编程模型

这里是引用多线程编程的代码编写模型：

1、高内聚，低耦合 :必须保证业务代码的高内聚、低耦合；

2、线程去操作(调用对外暴露的方法) 资源类。

这里使用一个卖票案例来说明传统的多线程下会出现的问题。
3个售票员出售20张票。

package com.juc.study.lockdemo;


/**
* @ClassName:
* @PackageName: com.juc.study.lockdemo
* @author: youjp
* @create: 2020-04-14 09:10
* @description: TODO 未考虑线程安全情况下
* @Version: 1.0
*/
public class SaleTicketTest {


    public static void main(String[] args) {


        //资源类
        SaleTicket saleTicket = new SaleTicket();


        //线程A
        new Thread(() -> {
            for (int i = 0; i < 40; i++) {
                saleTicket.saleTicket();
            }
        }, "A").start();


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


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




    }
}




//售票对象
class SaleTicket {
    private int number = 30;


    public  void saleTicket() {
        if (number > 0) {
            System.out.println(Thread.currentThread().getName() + "卖出第" + (number--) + "还剩" + number + "张票");
        }
    }
}

在没有对资源进行加锁条件下，出现了售票多卖的情况，且有多次售卖相同票数。

使用传统的关键字synchronized实现Lock锁

package com.juc.study.lockdemo;


/**
* @ClassName:
* @PackageName: com.juc.study.lockdemo
* @author: youjp
* @create: 2020-04-14 09:10
* @description: TODO 考虑线程安全情况下
* @Version: 1.0
*/
public class SaleTicketTest {


    public static void main(String[] args) {


        //资源类
        SaleTicket saleTicket = new SaleTicket();


        //线程A
        new Thread(() -> {
            for (int i = 0; i < 40; i++) {
                saleTicket.saleTicket();
            }
        }, "A").start();


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


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




    }
}



//售票对象
class SaleTicket {
    private int number = 50;


    public synchronized void saleTicket() {
        if (number > 0) {
            System.out.println(Thread.currentThread().getName() + "卖出第" + (number--) + "还剩" + number + "张票");
        }
    }
}

2.使用 juc.locks 包下的类操作 Lock 锁 + Lambda 表达式

Lock是一个接口，其实现类ReentranLock（可重入锁，后面章节会详细讲解）。

Lock的编程模型：

1、创建锁；
2、加锁：lock.lock()；
3、在try/catch里面写业务代码；
4、在try/catch的finally里面解锁lock.unlock()；
注意：Lock的加锁解锁要配对出现，即有一个lock.lock()加锁，就必须在finally里面有一个lock.unlock()，出现两个lock.lock()加锁，在finally里面也必须有两个lock.unlock(),

完整代码如下：

package com.juc.study.lockdemo;


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


/**
* @ClassName:
* @PackageName: com.juc.study.lockdemo
* @author: youjp
* @create: 2020-04-14 09:10
* @description: TODO 考虑线程安全情况下
* @Version: 1.0
*/
public class SaleTicketTest {


    public static void main(String[] args) {


        //资源类
        SaleTicket saleTicket = new SaleTicket();


        //线程A
        new Thread(() -> {
            for (int i = 0; i < 40; i++) {
                saleTicket.saleTicket();
            }
        }, "A").start();


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


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




    }
}




//售票对象
class SaleTicket {
    private int number = 50;


    //锁lock
    private Lock lock=new ReentrantLock();


    public void saleTicket() {
        //加锁
        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可以判断是否获得锁（通过isLocked（）方法）；3、synchronized 锁会自动释放！ Lock需要手动在 finally 释放锁，如果不释放锁，就会死锁，Lock的加锁解锁要配对出现；
4、synchronized线程1阻塞，线程2永久等待下去。 Lock可以 lock.tryLock(); // 尝试获取锁，如果尝试获取不到锁，可以结束等待；
5、synchronized 可重入，不可中断，非公平的。Lock锁，可重入、可以判断、可以公平！
公平：线程必须排队，必须先来后到；
非公平：线程可以插队。

有兴趣的老爷，可以关注我的公众号【一起收破烂】，回复【006】获取2021最新java面试资料以及简历模型120套哦~