Synchronized 与 Lock 卖票问题、区别

---

Synchronized 与 Lock 卖票问题、区别

一、传统 Synchronized

1、简介

• synchronized：本质是排队，是个锁

2、代码案例

package com.sgz.demo;

/**
 * 日期：2022/8/28 - 9:13
 * 需求：基本的卖票例子
 * 真正的多线程开发，公司中的开发
 * 线程就是一个单独的资源类，没有任何附属的操作
 * 1、属性，方法
 */
public class SaleTicketDemo01 {
    public static void main(String[] args) {
        // 并发，多个线程操作同一个资源类，把资源类丢入线程
        Ticket ticket = new Ticket();

        // 函数式接口，Lambda表达式 ( 参数 ) -> { 代码 }
        new Thread(() -> {
            for (int i = 1; i < 40; i++) {
                ticket.sale();
            }
        }, "A").start();

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

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

// 资源类 OOP（面向对象）
class Ticket {
    // 属性、方法，共30张票
    private int number = 30;

    // 卖票的方式
    // synchronized：本质是排队，是个锁
    public synchronized void sale() {
        if (number > 0) {
            System.out.println(Thread.currentThread().getName() + "卖出了" + (number--) + "票，剩余：" + number);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

二、Lock接口

1、简介

• 非公平锁：十分不公平，可以插队（默认）
• 公平锁：十分公平，可以先来后到

2、代码案例

package com.sgz.demo;

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

/**
 * 日期：2022/8/28 - 9:13
 * 需求：基本的卖票例子
 * 真正的多线程开发，公司中的开发
 * 线程就是一个单独的资源类，没有任何附属的操作
 * 1、属性，方法
 */
public class SaleTicketDemo02 {
    public static void main(String[] args) {
        // 并发，多个线程操作同一个资源类，把资源类丢入线程
        Ticket2 ticket = new Ticket2();

        // 函数式接口，Lambda表达式 ( 参数 ) -> { 代码 }
        new Thread(() -> {for (int i = 1; i < 40; i++) ticket.sale();}, "A").start();
        new Thread(() -> {for (int i = 1; i < 40; i++) ticket.sale();}, "B").start();
        new Thread(() -> {for (int i = 1; i < 40; i++) ticket.sale();}, "C").start();

    }
}

// Lock三部曲
// 1、new ReentrantLock();   new对象
// 2、lock.lock();   //加锁
//  3、lock.unlock();  // 解锁
// 资源类 OOP（面向对象）
class Ticket2 {
    // 属性、方法
    private int number = 30;

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

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

3、总结

基本使用步骤：

1. new ReentrantLock(); new对象
2. lock.lock(); 加锁
3. lock.unlock(); 解锁

三、Synchronized 和 Lock 区别

1. Synchronized 内置的Java关键字；Lock是一个Java类
2. Synchronized 无法判断获取锁的状态；Lock可以判断是否获取到了锁
3. Synchronized 会自动释放锁；Lock必须要手动释放锁，如果不释放锁，死锁
4. Synchronized 线程1（获取锁，阻塞）、线程2（等待，傻傻的等）；Lock就不一定会等待下去
5. Synchronized 可重入锁，不可以中断的，非公平；Lock，可重入锁，可以判断锁，非公平（可以自己设置）
6. Synchronized 适合锁少量的代码同步问题；Lock 适合锁大量的同步代码