JUC-Lock

什么是JUC

就是jdk为了操作多线程的一个工具包的简称

image.png

通过代码对比Lock和Synchronizied的用法和区别

Synchronizied

/**
 * @author 小鱼
 * @version 1.0
 * @date 2021/3/17 9:37 下午
 *  通过oop编程买票
 *
 *  真正的多线程开发，公司中的开发，降低耦合性
 *  线程就是一个单独的资源类，没有任何的附属操作
 *  1.属性    2.方法
 */
public class SaleTicket01 {
    public static void main(String[] args) {
        //创建资源类
        Ticket ticket = new Ticket();
        //总共三个线程共同操作一个资源类
        new Thread(()->{
            for (int i = 0; i < 50; i++) {
                ticket.buyTicket();
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 50; i++) {
                ticket.buyTicket();
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 50; i++) {
                ticket.buyTicket();
            }
        },"C").start();
    }
}
//资源类：OOP思想，只需要关注对象，不是面向接口编程
class Ticket{
    //属性：50张票
    private int num=50;
    //方法：同过synchronized实现同步方法，达到线程安全。synchronized的本质就是：队列+锁
    public synchronized  void buyTicket(){
        if(num>0){
            System.out.println(Thread.currentThread().getName()+"已经买了第"+(num--)+"张票!还剩下"+num);
        }
    }
}

Lock

Lock是一个接口，最常用的实现类是ReentrantLock
创建ReentrantLock有两种方式：非公平锁和公平锁

• 非公平锁

  
  非公平锁.png

这是默认的创建方式，非公平锁：就是不公平的，不是谁先进来谁就先执行。

• 公平锁

  
  公平锁.png

公平锁：就是公平的，是谁先进来谁就先执行。

/**
 * @author 小鱼
 * @version 1.0
 * @date 2021/3/17 10:00 下午
 *
 *  通过Lock的方法实现多线程同步安全买票
 *
 *  Lock三部曲用法：
 *      1定义一个类变量Lock,
 *      2在try 代码块中通过lock.lock();添加锁，
 *      3在finally代码块中解锁； lock.unlock();
 */
public class SaleTicketByLock02 {
    public static void main(String[] args) {
        //创建资源类
        Ticket2 ticket = new Ticket2();
        //总共三个线程共同操作一个资源类
        new Thread(()->{
            for (int i = 0; i < 50; i++) {
                ticket.buyTicket();
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 50; i++) {
                ticket.buyTicket();
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 50; i++) {
                ticket.buyTicket();
            }
        },"C").start();
    }
}
class Ticket2{
    //属性：50张票
    private int num=50;
    Lock lock =new ReentrantLock();
    //方法：通过Lock达到线程安全。
    public  void buyTicket(){
        //加锁
        lock.lock();
        try {
            //业务代码
            if(num>0){
                System.out.println(Thread.currentThread().getName()+"已经买了第"+(num--)+"张票!还剩下"+num);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //解锁
            lock.unlock();
        }
    }
}

Lock和Synchronized区别总结

1.Lock是接口，synchronized是Java的关键字
2.Lock适合代码量大的地方使用，synchronized使用代码量小的地方使用
3.Lock：可重入锁，可以调整是否是公平锁还是非公平锁，可以判断锁。synchronized：可重入锁，非公平锁，不可中断
4.Lock：必须手动释放锁，不然会造成死锁。synchronized：会主动释放锁
5.Lock：可以判断锁的状态，是否获到了锁。synchronized：不能判断锁的状态
6.Lock：不会一直等待下去，因为tryLock()方法。synchronized：可能因为线程1获取到了锁（阻塞），线程2一直等待下去