JUC（2）Lock锁与Synchronized（重点）

一、传统的Synchronized （关键字）

• 一个买票案例

package com.wlw.demo01;
/**
 * 真正的多线程开发
 * 线程就是一个单独的资源类，没有任何的附属操作！ (只有属性和方法)
 */
public class SaleTicketDemo01 {
    public static void main(String[] args) {
        //多线程操作
        //并发：多线程操作同一个资源类，把资源类丢入线程
        final Ticket ticket = new Ticket();

        //@FunctionalInterface 函数式接口 jdk1.8之后 可用lambda表达式来代替
        new Thread(new Runnable() {
            public void run() {
                for (int i = 0; i < 40; i++) {
                    ticket.sale();
                }
            }
        },"A").start();

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

        new Thread(()->{
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        },"C").start();
    }
}
//资源类
//属性+方法
//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是一个接口）

2.1 ReentrantLock 可重入锁中的公平锁与非公平锁

• Lock lock = new ReentrantLock();
  

• 点进去看一下源码

• /**
   * Creates an instance of {@code ReentrantLock}.
   * This is equivalent to using {@code ReentrantLock(false)}.
   */
  public ReentrantLock() {
      sync = new NonfairSync(); //非公平锁
  }
  
  /**
   * Creates an instance of {@code ReentrantLock} with the
   * given fairness policy.
   *
   * @param fair {@code true} if this lock should use a fair ordering policy
   */
  public ReentrantLock(boolean fair) {
      sync = fair ? new FairSync() : new NonfairSync(); //FairSync()为公平锁
  }
  

• 非公平锁： 十分不公平，可以插队；(默认为非公平锁) （这个可以保证运行时间短的线程先执行完，不用一直等待前面的需要很多时间才能执行完的线程）

• 公平锁： 十分公平，必须先来后到（严格按照先来后到的顺序执行）；

2.2与Synchronized不同的加锁方式的买票案例（Lock锁）

• lock锁 三部曲
  • 1、 Lock lock=new ReentrantLock(); 创建锁
  • 2、 lock.lock() 加锁
  • 3、 finally块中 解锁：lock.unlock();

package com.wlw.demo01;

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

/**
 * SaleTicketDemo01 用的是synchronized 关键字加锁，SaleTicketDemo02用lock锁
 */
public class SaleTicketDemo02 {
    public static void main(String[] args) {
        //多线程操作
        //并发：多线程操作同一个资源类，把资源类丢入线程
        Ticket2 ticket = new Ticket2();

        //@FunctionalInterface 函数式接口 jdk1.8之后 可用lambda表达式来代替
        new Thread(()->{ for (int i = 0; i < 40; i++) ticket.sale();},"A").start();
        new Thread(()->{ for (int i = 0; i < 40; i++) ticket.sale(); },"B").start();
        new Thread(()->{ for (int i = 0; i < 40; i++) ticket.sale(); },"C").start();
    }
}

//lock锁 三部曲
//1、    Lock lock=new ReentrantLock();
//2、    lock.lock() 加锁
//3、    finally块中 解锁：lock.unlock();
class Ticket2{
    private int number = 50;

    Lock lock = new ReentrantLock(); //创建一个可重入锁

    public void sale(){
        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接口（在jvm层面，Lock是个java类）
• 2、Synchronized 无法判断获取锁的状态，Lock可以判断是否获取到锁；
• 3、Synchronized 会自动释放锁（a 线程执行完同步代码会释放锁 ；b 线程执行过程中发生异常会释放锁），lock必须要手动加锁和手动释放锁！（unlock()方法释放锁，否则容易造成线程死锁；）
• 4、用synchronized关键字的两个线程1和线程2，如果当前线程1获得锁，线程2线程等待。如果线程1阻塞，线程2则会一直等待下去， lock就不一定会一直等待下去，lock会有一个trylock去尝试获取锁，不会造成长久的等待，如果尝试获取不到锁，线程可以不用一直等待就结束了；
• 5、Synchronized 是可重入锁，不可以中断的，默认就是非公平的；Lock，可重入的，可以判断锁，可以自己设置公平锁和非公平锁（默认是非公平的，如果创建可重入锁时加了true就是获得公平锁）；
• 6、Synchronized 适合锁少量的代码同步问题，Lock适合锁大量的同步代码；