Lock锁的使用

Lock锁

        为了更清晰的表达如何加锁和释放锁,JDK5以后提供了一个新的锁对象Lock,更加灵活、方便。

        Lock实现提供比使用synchronized方法和语句可以获得更广泛的锁定操作。

        Lock是接口不能直接实例化,这里采用它的实现类ReentrantLock来构建Lock锁对象。

方法名称:

        public ReentrantLock()

说明:

        获得Lock锁的实现类对象。

Lock的API

        void lock()     获得锁

        void unlock()    释放锁

看一下演示代码:

public class ThreadDemo5 {
    //模拟取钱案例
    public static void main(String[] args) {
        Accout acc=new Accout("ICBC-111",100000);
        new DrawThread(acc,"小明").start();
        new DrawThread(acc,"小红").start();

    }
}




public class DrawThread extends Thread {
    private Accout acc;
    public DrawThread(Accout acc, String name) {
        super(name);
        this.acc = acc;
    }
    @Override

    public void run() {
        //取钱的
        acc.drawMoney(100000);
    }
}





public class Accout{
        private String cardId;
        private double money;
        private Lock lock=new ReentrantLock();

        public String getCardId() {
            return cardId;
        }

        public void setCardId(String cardId) {
            this.cardId = cardId;
        }

        public double getMoney() {
            return money;
        }

        public void setMoney(double money) {
            this.money = money;
        }

        public Accout(String cardId, double money) {
            this.cardId = cardId;
            this.money = money;
        }

        public Accout() {
        }

        public String toString() {
            return "Accout{cardId = " + cardId + ", money = " + money + "}";
        }

        public void drawMoney(double money) {
            //先获取是谁来取钱,现成的名字就是人名
            String name =Thread.currentThread().getName();
            //判断账户是否够钱
            lock.lock();//上锁
            try {
                if (this.money >= money) {
                    //取钱
                    System.out.println(name + "来取钱成功,吐出"+money);
                    //更新余额
                    this.money -= money;
                    System.out.println(name + "取钱后剩余:"+this.money);
                }else {
                    System.out.println(name + "来取钱,余额不足!");
                }
            } finally {
                lock.unlock();//释放锁
            }

        }
    }

  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
在C++中,unique_lock是一个用于管理互斥的RAII(资源获取即初始化)类。它提供了一种更灵活的方式来管理互斥的加和解操作。 unique_lock的解操作非常简单,只需要调用其成员函数unlock()即可。例如: ```cpp #include <iostream> #include <mutex> std::mutex mtx; void foo() { std::unique_lock<std::mutex> lock(mtx); // 互斥已经在构造unique_lock对象时被加 // 执行一些需要保护的操作 // 解互斥 lock.unlock(); // 在解后可以执行一些不需要互斥保护的操作 // 再次加互斥 lock.lock(); // 执行一些需要保护的操作 // 解互斥 lock.unlock(); } int main() { foo(); return 0; } ``` 在上面的示例中,我们首先创建了一个std::mutex对象mtx,然后在函数foo()中创建了一个unique_lock对象lock,并将mtx作为参数传递给它。在unique_lock对象的构造函数中,互斥会被自动加。然后我们可以执行一些需要保护的操作。当我们调用lock.unlock()时,互斥会被解,这样我们就可以执行一些不需要互斥保护的操作。最后,我们可以再次调用lock.lock()来重新加互斥,并执行一些需要保护的操作。最后,当unique_lock对象超出作用域时,析构函数会自动解互斥。 需要注意的是,unique_lock对象的unlock()和lock()成员函数可以在任何时候调用,而不仅仅是在构造函数和析构函数中。这使得我们可以更灵活地控制互斥的加和解操作。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值