java 锁的使用_Java中锁的应用之

关于Lock的说明，我看大家看JDK就可以了。

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

要注意的是锁定和取消锁定出现在不同作用范围中时，必须谨慎地确保保持锁定时所执行的所有代码用 try-finally 或 try-catch 加以保护，以确保在必要时释放锁。

Lock 类还可以提供与隐式监视器锁完全不同的行为和语义，如保证排序、非重入用法或死锁检测。如果某个实现提供了这样特殊的语义，则该实现必须对这些语义加以记录。

注意，Lock 实例只是普通的对象，其本身可以在 synchronized 语句中作为目标使用。获取 Lock 实例的监视器锁与调用该实例的任何 lock()方法没有特别的关系。为了避免混淆，建议除了在其自身的实现中之外，决不要以这种方式使用 Lock 实例。

除非另有说明，否则为任何参数传递 null 值都将导致抛出 NullPointerException。

我们来看一段代码和运行结果：

创建对象：

Java代码 package com.entity;

public class BankCard {

private String cardid = "XZ456789";

private int balance = 10000;

public String getCardid() {

return cardid;

}

public void setCardid(String cardid) {

this.cardid = cardid;

}

public int getBalance() {

return balance;

}

public void setBalance(int balance) {

this.balance = balance;

}

}

这个对象会被不同线程操作。

创建两个线程实现接口，一个作为儿子只消费，一个作为父亲只挣钱。可是儿子消费太快也太多，而年老的父亲挣钱慢也少。不久他们家的钱就成负数了，希望用这个例子也引发一下大家都父爱的思考吧。但是消费和存钱不能同时进行，我们在结果中可以看出。

Java代码 package com.thread;

import java.util.concurrent.locks.Lock;

import com.entity.BankCard;

/**

* @说明 儿子类，只消费

*/

public class Consumer implements Runnable {

BankCard bc = null;

Lock lock = null;

Consumer(BankCard bc, Lock lock) {

this.bc = bc;

this.lock = lock;

}

public void run() {

try {

while(true){

lock.lock();

System.out.print("儿子要消费，现在余额：" + bc.getBalance() + "\t");

bc.setBalance(bc.getBalance() - 2000);

System.out.println("儿子消费2000元，现在余额：" + bc.getBalance());

lock.unlock();

Thread.sleep(1 * 1000);

}

} catch (Exception e) {

e.printStackTrace();

}

}

}

下面是另一个线程类：

Java代码 package com.thread;

import java.util.concurrent.locks.Lock;

import com.entity.BankCard;

/**

* @说明 父亲类，只挣钱

*/

public class Consumer2 implements Runnable {

BankCard bc = null;

Lock lock = null;

Consumer2(BankCard bc, Lock lock) {

this.bc = bc;

this.lock = lock;

}

public void run() {

try {

while(true){

lock.lock();

System.out.print("父亲要存钱，现在余额：" + bc.getBalance() + "\t");

bc.setBalance(bc.getBalance() + 500);

System.out.println("父亲存入500元，现在余额：" + bc.getBalance());

lock.unlock();

Thread.sleep(3 * 1000);

}

} catch (Exception e) {

e.printStackTrace();

}

}

}

下面创建一个测试类，直接运行看效果：

Java代码 package com.thread;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;

import com.entity.BankCard;

public class MainThread {

public static void main(String[] args) {

BankCard bc = new BankCard();

Lock lock = new ReentrantLock();

ExecutorService pool = Executors.newCachedThreadPool();

Consumer cm1 = new Consumer(bc, lock);

Consumer2 cm2 = new Consumer2(bc, lock);

pool.execute(cm1);

pool.execute(cm2);

}

}

把锁对象传进线程，线程会使用该锁来进行对对象的锁定和解锁操作。

运行效果：

Java代码 儿子要消费，现在余额：10000    儿子消费2000元，现在余额：8000

父亲要存钱，现在余额：8000 父亲存入500元，现在余额：8500

儿子要消费，现在余额：8500 儿子消费2000元，现在余额：6500

儿子要消费，现在余额：6500 儿子消费2000元，现在余额：4500

儿子要消费，现在余额：4500 儿子消费2000元，现在余额：2500

父亲要存钱，现在余额：2500 父亲存入500元，现在余额：3000

儿子要消费，现在余额：3000 儿子消费2000元，现在余额：1000

儿子要消费，现在余额：1000 儿子消费2000元，现在余额：-1000

父亲要存钱，现在余额：-1000    父亲存入500元，现在余额：-500

儿子要消费，现在余额：-500 儿子消费2000元，现在余额：-2500

儿子要消费，现在余额：-2500    儿子消费2000元，现在余额：-4500

儿子要消费，现在余额：-4500    儿子消费2000元，现在余额：-6500

我们看到，由于儿子不断的消费他们的钱很快花完了。

但是通过打印也可以发现，每次儿子或者父亲操作时，卡里面的钱是对方已经操作完的。

如果我们把一些代码注释掉：

Java代码 lock.lock();

lock.unlock();

那么就没有锁概念，我们再来看一下运行结果：

Java代码 儿子要消费，现在余额：10000    儿子消费2000元，现在余额：8000

父亲要存钱，现在余额：8000 父亲存入500元，现在余额：8500

儿子要消费，现在余额：8500 儿子消费2000元，现在余额：6500

儿子要消费，现在余额：6500 儿子消费2000元，现在余额：4500

儿子要消费，现在余额：4500 儿子消费2000元，现在余额：2500

父亲要存钱，现在余额：2500 父亲存入500元，现在余额：3000

儿子要消费，现在余额：3000 儿子消费2000元，现在余额：1000

儿子要消费，现在余额：1000 儿子消费2000元，现在余额：-1000

儿子要消费，现在余额：-1000    儿子消费2000元，现在余额：-3000

父亲要存钱，现在余额：-3000    父亲存入500元，现在余额：-2500

儿子要消费，现在余额：-2500    儿子消费2000元，现在余额：-4500

我想不用多说了。

如果父亲没有锁，而儿子拿走卡以后就锁定不释放，那会是什么效果呢？

Java代码 儿子要消费，现在余额：10000    父亲要存钱，现在余额：10000    父亲存入500元，现在余额：8500

儿子消费2000元，现在余额：8000

儿子要消费，现在余额：8500 儿子消费2000元，现在余额：6500

儿子要消费，现在余额：6500 儿子消费2000元，现在余额：4500

父亲要存钱，现在余额：4500 父亲存入500元，现在余额：5000

儿子要消费，现在余额：4500 儿子消费2000元，现在余额：3000

儿子要消费，现在余额：3000 儿子消费2000元，现在余额：1000

儿子要消费，现在余额：1000 儿子消费2000元，现在余额：-1000

父亲要存钱，现在余额：-1000    父亲存入500元，现在余额：-500

儿子要消费，现在余额：-1000    儿子消费2000元，现在余额：-2500

儿子要消费，现在余额：-2500    儿子消费2000元，现在余额：-4500

儿子要消费，现在余额：-4500    儿子消费2000元，现在余额：-6500

父亲要存钱，现在余额：-6500    儿子要消费，现在余额：-6500    父亲存入500元，现在余额：-6000

儿子消费2000元，现在余额：-8000

儿子要消费，现在余额：-8000    儿子消费2000元，现在余额：-10000

儿子要消费，现在余额：-10000   儿子消费2000元，现在余额：-12000

我们可以看到只有儿子在消费透支了

用此来说明锁的应用和希望引起大家的一些思考，不要只写代码和每天玩了，为了你学习你的父母很辛苦，看完以后快给家里打个电话或者可以的就回家给父母做顿饭吧！