第2章 Lock 接口

2.1 Synchronized

2.1.1 Synchronized 关键字回顾

  synchronized是Java中的关键字,是一种同步锁。它修饰的对象有以下几种:

1.修饰一个代码块 , 被修饰的代码块称为同步语句块 , 其作用的范围是大括号{}括起来的代码 , 作用的对象是调用这个代码块的对象 ;

2.修饰一个方法 , 被修饰的方法称为同步方法 , 其作用的范围是整个方法 , 作用的对象是调用这个方法的对象 ;

  虽然可以使用 synchronized来定义方法,但synchronized并不属于方法定义的一部分,因此, synchronized关键字不能被继承。如果在父类中的某个方法使用了synchronized关键字,而在子类中覆盖了这个方法,在子类中的这个方法默认情况下并不是同步的,而必须显式地在子类的这个方法中加上synchronized关键字才可以。当然,还可以在子类方法中调用父类中相应的方法,这样虽然子类中的方法不是同步的,但子类调用了父类的同步方法,因此,子类的方法也就相当于同步了。

3.修改一个静态的方法,其作用的范围是整个静态方法, 作用的对象是这个类的所有对象;
4.修改一个类, 其作用的范围是 synchronized 后面括号括起来的部分,作用主的对象是这个类的所有对象。


2.1.2 售票案例

 

复制代码
package JUC.sync;

//第一步 创建资源类,定义属性和操作方法
class Ticket {
    //票数
    private int number = 30;
    //操作方法:卖票
    public synchronized void sale(){
        //判断:是否有票
        if(number > 0){
            System.out.println(Thread.currentThread().getName()+
                    " : 卖出 :"+(number--)+" 剩下: "+number);
        }
    }
}

public class SaleTicket {
    //第二步 创建多个线程,调用资源类的操作方法
    public static void main(String[] args) {
        //创建ticket对象
        Ticket ticket = new Ticket();
        //创建三个线程
        new Thread(() -> {
            //调用卖票方法
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        },"AA").start();

        new Thread(() -> {
            //调用卖票方法
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        },"BB").start();

        new Thread(() -> {
            //调用卖票方法
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        },"CC").start();
    }
}
复制代码

 

 

2.2 什么是Lock

Lock 锁实现提供了比使用同步方法和语句可以获得的更广泛的锁操作。它们允许更灵活的结构,可能具有非常不同的属性,并且可能支持多个关联的条件对象。Lock 提供了比synchronized更多的功能。


Lock与的Synchronized区别

● Lock不是Java语言内置的, synchronized是Java语言的关键字,因此是内置特性。Lock 是一个类,通过这个类可以实现同步访问;
● Lock 和synchronized 有一点非常大的不同,采用 synchronized 不需要用户去手动释放锁,当synchronized方法或者synchronized 代码块执行完之后,系统会自动让线程释放对锁的占用 ; 而Lock则必须要用户去手动释放锁 , 如果没有主动释放锁 , 就有可能导致出现死锁现象。

复制代码
package JUC.lock;

import java.util.concurrent.locks.ReentrantLock;

//第一步 创建资源类,定义属性和操作方法
class LTicket {
    //票数量
    private int number = 30;

    //创建可重入锁
    private final ReentrantLock lock = new ReentrantLock();
    //卖票方法
    public void sale() {
        //上锁
        lock.lock();
        try {
            //判断:是否有票
            if(number > 0){
                System.out.println(Thread.currentThread().getName()+
                        " : 卖出 :"+(number--)+" 剩下: "+number);
            }
        } finally {
            //解锁
            lock.unlock();
        }
    }

}

public class LSaleTicket {
    //第二步 创建多个线程,调用资源类的操作方法
    public static void main(String[] args) {
        LTicket ticket = new LTicket();

        //创建三个线程
        new Thread(() -> {
            //调用卖票方法
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        },"AA").start();

        new Thread(() -> {
            //调用卖票方法
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        },"BB").start();

        new Thread(() -> {
            //调用卖票方法
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
        },"CC").start();
    }
}
复制代码

Lock 和 synchronized 有以下几点不同:

1. Lock 是一个接口,而 synchronized 是Java中的关键字, synchronized是内置的语言实现;
2. synchronized 在发生异常时,会自动释放线程占有的锁,因此不会导致死锁现象发生;而Lock在发生异常时,如果没有主动通过unLock()去释放锁,则很可能造成死锁现象,因此使用Lock时需要在finally块中释放锁;
3. Lock 可以让等待锁的线程响应中断,而synchronized却不行,使用synchronized时,等待的线程会一直等待下去,不能够响应中断;
4.通过Lock可以知道有没有成功获取锁,而synchronized却无法办到。
5. Lock 可以提高多个线程进行读操作的效率。

在性能上来说,如果竞争资源不激烈,两者的性能是差不多的,而当竞争资源非常激烈时(即有大量线程同时竞争) , 此时Lock的性能要远远优于synchronized。

 

posted @   狂热搬砖家  阅读(24)  评论(0编辑  收藏  举报
相关博文:
阅读排行:
· 微软正式发布.NET 10 Preview 1:开启下一代开发框架新篇章
· C# 集成 DeepSeek 模型实现 AI 私有化(本地部署与 API 调用教程)
· DeepSeek R1 简明指南:架构、训练、本地部署及硬件要求
· 没有源码,如何修改代码逻辑?
· NetPad:一个.NET开源、跨平台的C#编辑器
点击右上角即可分享
微信分享提示