JUC并发编程 -- synchronized & Lock锁 & 两者区别

Posted 2021-09-06 Z && Y

1. synchronized 示例: 售票员卖票

synchronized详解

代码:

public class Test {
    public static void main(String[] args) {
        /* 题目：三个售票员 卖出 30张票 * 多线程编程的企业级套路： *
         *  1. 在高内聚低耦合的前提下，
         *  线程 操作(对外暴露的调用方法) 资源类 */
        Ticket ticket = new Ticket();


        // 并发:多线程操作同一个资源类，把资源类丢入线程
        new Thread(new Runnable() {
            // @FunctionalInterface 函数式接口，jdk1.8Lambda表达式（参数)->{代码}
            @Override
            public void run() {
                for (int i = 1; i <= 40; i++) {
                    ticket.saleTicket();
                    try {
                    // 每卖一张票 休眠100ms
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }, "A").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <= 40; i++) {
                    ticket.saleTicket();
                    try {
                      // 每卖一张票 休眠100ms
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }, "B").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <= 40; i++) {
                    ticket.saleTicket();
                    try {
                      // 每卖一张票 休眠100ms
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }, "C").start();
    }
}

class Ticket { // 资源类
    private int number = 20;

    // synchronized本质:队列，锁(锁的是对象和class)
    public synchronized void saleTicket() {
        if (number > 0) {
            System.out.println(Thread.currentThread().getName() + "卖出第 " + (number--) + "票,还剩下:" + number);
        }
    }
}

运行结果:

---

2. Lock锁 示例: 售票员卖票

Lock锁详解

代码:

public class Test {
    public static void main(String[] args) {
        /* 题目：三个售票员 卖出 30张票 * 多线程编程的企业级套路： *
         *  1. 在高内聚低耦合的前提下，
         *  线程 操作(对外暴露的调用方法) 资源类 */
        Ticket ticket = new Ticket();

        new Thread(() -> {
            for (int i = 1; i <= 40; i++) {
                ticket.saleTicket();
                try {
                  // 每卖一张票 休眠100ms
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "A").start();

        new Thread(() -> {
            for (int i = 1; i <= 40; i++) {
                ticket.saleTicket();
                try {
                  // 每卖一张票 休眠100ms
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "B").start();

        new Thread(() -> {
            for (int i = 1; i <= 40; i++) {
                ticket.saleTicket();
                try {
                  // 每卖一张票 休眠100ms
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "C").start();
    }
}

class Ticket { // 资源类
    private final Lock lock = new ReentrantLock();
    private int number = 20;

    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();
        }
    }
}

运行结果:

说明:

---

3. 两者区别

1. 首先synchronized是java内置关键字，在jvm层面，Lock是个java类；
2. synchronized无法判断是否获取锁的状态，Lock可以判断是否获取到锁；
3. synchronized会自动释放锁(a 线程执行完同步代码会释放锁 ；b 线程执行过程中发生异常会释放锁)，Lock需在finally中手工释放锁（unlock()方法释放锁），否则容易造成线程死锁；
4. 用synchronized关键字的两个线程1和线程2，如果当前线程1获得锁，线程2线程等待。如果线程1阻塞，线程2则会一直等待下去，而Lock锁就不一定会等待下去，如果尝试获取不到锁，线程可以不用一直等待就结束了；
5. synchronized的锁可重入、不可中断、非公平，而Lock锁可重入、可判断、可公平（两者皆可）
6. Lock锁适合大量同步的代码的同步问题，synchronized锁适合代码少量的同步问题。

---

---