JUC之初识锁

最新推荐文章于 2024-11-03 11:01:20 发布

aYuIsAyU

最新推荐文章于 2024-11-03 11:01:20 发布

阅读量107

点赞数

分类专栏： JUC 文章标签： java

本文链接：https://blog.csdn.net/Y_Ace/article/details/124203145

版权

JUC 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

先来看一段代码

使用三个线程来模拟三个售票员售票, 票数是固定的, 并且在三个售票员之间时共享的。

public class SaleTicket {
    public static void main(String[] args) {
        //创建Ticket对象
        Ticket ticket = new Ticket();
        //创建三个线程
        new Thread(() -> {
            for (int i = 0; i < 20; i++) {
                ticket.sale();
            }
        }, "AA").start();
        new Thread(() -> {
            for (int i = 0; i < 20; i++) {
                ticket.sale();
            }
        }, "BB").start();
        new Thread(() -> {
                for (int i = 0; i < 20; i++) {
                    ticket.sale();
                }
        }, "CC").start();
    }
}
class Ticket {
    private static int number = 20;
    //买票方法
    public void sale() {
        //判断是否有余票
        if (number > 0) {
            System.out.println(Thread.currentThread().getName() + " : 卖出一张票, 剩余票数: " + (--number));
        }
    }
}

来看一下运行结果:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QNqn1h0F-1650025372945)(/img/2022-03-26/01.png)]

我们发现一个很奇怪的事情, 买票的顺序不是从19到0, 是一个很混乱的顺序, 这是为什么呢? 因为我们在多个线程进行操作的时候难免会发生线程抢占, 明明我这个线程进来做完操作了准备打印结果, 但这时又被另一个线程抢了过去运行权, 它先打印了结果, 我这好不容易再次抢了回来, 可这时已经晚了, 打印出了原本的结果, 可这个结果却是过时错误的结果, 那么怎样避免这样的事发生呢, 我们就需要给买票操作加把锁。

锁

synchronized

synchronized是Java中的关键字, 中文意思是同步, 也称之为"同步锁"。

作用主要有三个:

原子性: 确保线程互斥地访问同步代码
可见性: 保证共享变量的修改能够及时可见, 其实是通过Java内存模型中的"对一个变量unlock操作之前, 必须要同步到主内存中; 如果对一个变量进行lock操作, 则将会清空工作内存中此变量的值, 在执行引擎使用此变量前, 需要重新从主内存中load操作或assign操作初始化变量值 "来保证的
有序性: 有效解决重排序问题, 即"一个unlock操作先行发生(happen-before)于后面对同一个锁的lock操作"

synchronized的3种使用方式:

修饰实例方法: 作用于当前实例加锁
```
synchronized void method() {
    //todo
}
```
注意:
- 在定义接口方法时不能使用synchronized关键字。
- 构造方法不能使用synchronized关键字, 但可以使用synchronized代码块来进行同步。
修饰静态方法: 作用于当前类对象加锁
```
public synchronized static void method() {
   //todo
}
```
与上一个不同的是, 被synchronized修饰的静态方法是对于这个类的所有实例对象都起作用的, 也就是说所有这个类的实例对象用的是同一把锁。

修饰代码块: 指定加锁对象, 对给定对象加锁

//给这个类的某一代码块加锁
synchronized(this) {
    //todo
}
//给这个对象加锁
Object obj;
synchronized(obj) {
    //todo
}

现在我们就可以使用synchronized帮我们上边的例子进行加锁操作, 很简单:

/**
* 三个线程卖票
*/
public class SaleTicket {
    public static void main(String[] args) {
        //创建Ticket对象
        Ticket ticket = new Ticket();
        //创建三个线程
        new Thread(() -> {
            for (int i = 0; i < 20; i++) {
                ticket.sale();
            }
        }, "AA").start();
        new Thread(() -> {
            for (int i = 0; i < 20; i++) {
                ticket.sale();
            }
        }, "BB").start();
        new Thread(() -> {
                for (int i = 0; i < 20; i++) {
                    ticket.sale();
                }
        }, "CC").start();
    }
}
class Ticket {
    private static int number = 20;
    //买票方法
    public synchronized void sale() {
        //判断是否有余票
        if (number > 0) {
            System.out.println(Thread.currentThread().getName() + " : 卖出一张票, 剩余票数: " + (--number));
        }
    }
}

看一看运行结果:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sGQceIQe-1650025372946)(/img/2022-03-26/02.png)]

很明显, 票按照正常的顺序出售了。

Lock接口

Lock是java.util.concurrent.locks包下常用的接口

代表实现类是ReentrantLock(可重入锁)

常用方法:

lock(): 获取锁, 也就是给下面操作上锁
unlock(): 释放锁

被lock()上锁后即使发生异常也不会释放锁, 所以我们通常在lock()方法后紧跟try…catch…块, 并将unlock()释放锁方法放在finally块中, 以此来保证锁的释放, 防止死锁的产生。

下面我们使用Lock接口对上面的例子进行修改:

/**
* 三个线程卖票
*/
public class SaleTicket {
    public static void main(String[] args) {
        //创建Ticket对象
        Ticket ticket = new Ticket();
        //创建三个线程
        new Thread(() -> {
            for (int i = 0; i < 20; i++) {
                ticket.sale();
            }
        }, "AA").start();
        new Thread(() -> {
            for (int i = 0; i < 20; i++) {
                ticket.sale();
            }
        }, "BB").start();
        new Thread(() -> {
                for (int i = 0; i < 20; i++) {
                    ticket.sale();
                }
        }, "CC").start();
    }
}
class Ticket {
    private static int number = 20;
    //创建可重入锁
    private final ReentrantLock lock = new ReentrantLock();
    //买票方法
    public void sale() {
        //上锁
        lock.lock();
        //lock()方法一定紧跟try块
        try {
            //判断是否有余票
            if (number > 0) {
                System.out.println(Thread.currentThread().getName() + " : 卖出一张票, 剩余票数: " + (--number));
            }
        } finally {
            lock.unlock();
        }

    }
}