3、Lock锁

3.1. 多线程的编程模型

多线程编程的代码编写模型:

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

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

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

要按照多线程的编程模型来实现Lock锁。如下方式,在企业中静止这样写。

package com.interview.concurrent.lock;

/**
 * @author DDKK.COM 弟弟快看,程序员编程资料站
 * @description 描述
 * @date 2023/2/21 11:15
 */
public class SaleTicketUseSynchronizeedError {
   
     
    public static void main(String[] args) {
   
     
        //1、错误的写法
        SaleTicketThreadError saleTicketThreadError = new SaleTicketThreadError();
        for (int i=0;i<30;i++) new Thread(saleTicketThreadError,"A").start();
        for (int i=0;i<30;i++) new Thread(saleTicketThreadError,"B").start();
        for (int i=0;i<30;i++) new Thread(saleTicketThreadError,"C").start();
        for (int i=0;i<30;i++) new Thread(saleTicketThreadError,"D").start();
        for (int i=0;i<30;i++) new Thread(saleTicketThreadError,"E").start();
    }
}

/**
 *  @description: 错误的写法,不能让资源和方法高度封装,达不到高内聚
 *  @author DDKK.COM 弟弟快看,程序员编程资料站
 *  @date 2023/2/20 19:45
 */
class SaleTicketThreadError implements Runnable{
   
     
    int ticketNumber = 50;

    @Override
    public synchronized void run() {
   
     
        if(ticketNumber  0)
            System.out.println(Thread.currentThread().getName() + "卖出第" + (ticketNumber--) + "张票,还剩" + ticketNumber + "张票");
    }
}

正确的写法是:将方法和资源单独封装,不要和线程有任何关系(线程是通过方法去操作资源的)。

package com.interview.concurrent.lock;

/**
 * @author DDKK.COM 弟弟快看,程序员编程资料站
 * @description 描述:卖票,5个售票员卖出50张票
 * @date 2023/2/20 19:29
 */
public class SaleTicketUseSynchronizeed {
   
     

    public static void main(String[] args) {
   
     

       //2、正确的写法,将资源和方法高度封装,达到高内聚
        SaleTicket saleTicket = new SaleTicket();
        new Thread(()-{
   
     
            for (int i=0;i<20;i++) saleTicket.saleTicket();
        },"A").start();
        new Thread(()-{
   
     
            for (int i=0;i<20;i++) saleTicket.saleTicket();
        },"B").start();
        new Thread(()-{
   
     
            for (int i=0;i<20;i++) saleTicket.saleTicket();
        },"C").start();
        new Thread(()-{
   
     
            for (int i=0;i<20;i++) saleTicket.saleTicket();
        },"D").start();
        new Thread(()-{
   
     
            for (int i=0;i<20;i++) saleTicket.saleTicket();
        },"E").start();

    }
}

/**
 *  @description: 资源类:将属性(票)和方法(卖票)封装起来,实现了高内聚
 *  @author DDKK.COM 弟弟快看,程序员编程资料站
 *  @date 2023/2/20 19:42
 */
class SaleTicket{
   
     
    int ticketNumber = 50;
    //卖票方法
    public synchronized void saleTicket(){
   
     
        if(ticketNumber  0)
            System.out.println(Thread.currentThread().getName() + "卖出第" + (ticketNumber--)  + "张票,还剩" + ticketNumber + "张票");
    }
}

3.3. 使用juc.locks包下的类实现Lock锁

3.3.1. Lock的编程模型

使用 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(),

3.3.2. 示例代码

完整代码如下:

package com.interview.concurrent.lock;

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

/**
 * @author DDKK.COM 弟弟快看,程序员编程资料站
 * @description 描述
 * @date 2023/2/21 11:41
 */
public class SaleTicketUseLock {
   
     

    public static void main(String[] args) {
   
     
        SaleTicketLock saleTicketLock = new SaleTicketLock();
        new Thread(()-{
   
     for(int i=0;i<20;i++) saleTicketLock.saleTicket();},"A").start();
        new Thread(()-{
   
     for(int i=0;i<20;i++) saleTicketLock.saleTicket();},"B").start();
        new Thread(()-{
   
     for(int i=0;i<20;i++) saleTicketLock.saleTicket();},"C").start();
        new Thread(()-{
   
     for(int i=0;i<20;i++) saleTicketLock.saleTicket();},"D").start();
        new Thread(()-{
   
     for(int i=0;i<20;i++) saleTicketLock.saleTicket();},"E").start();
    }
}

class SaleTicketLock{
   
     
    int ticketNumber = 50;
    //1、创建锁
    Lock lock = new ReentrantLock();

    public void saleTicket(){
   
     
        //2、加锁
        lock.lock();
        try{
   
     
            //3、业务代码
            if(ticketNumber  0)
                System.out.println(Thread.currentThread().getName() + "卖出第" + (ticketNumber--) + "张票,还剩" + ticketNumber + "张票");
        }catch(Exception e) {
   
     
            e.printStackTrace();
        }finally {
   
     
            //4、解锁
            lock.unlock();
        }
    }
}

3.3. synchronized 和 Lock 区别

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锁,可重入、可以判断、可以公平!

公平:线程必须排队,必须先来后到;

非公平:线程可以插队。

出现;

4、synchronized线程1阻塞,线程2永久等待下去。 Lock可以 lock.tryLock(); // 尝试获取锁,如果尝试获取不到锁,可以结束等待;

5、synchronized 可重入,不可中断,非公平的。Lock锁,可重入、可以判断、可以公平!

公平:线程必须排队,必须先来后到;

非公平:线程可以插队。