这一篇博文是【大数据技术●降龙十八掌】系列文章的其中一篇,点击查看目录:大数据技术●降龙十八掌
synchronized可以实现同步访问,java.util.concurrent.locks包下的Lock也可以实现同步访问。
synchronized是java中的一个关键字,是Java语言内置的特性。处于synchronized作用下的代码块或者方法代码块,是不允许两个线程同时进入,不管是读操作还是写操作,都是不允许同时进行的,这在高并发的情况下对性能影响很大。而Lock更复杂,控制也更精细,另外Lock提供的功能更丰富。
1、Lock
Lock是一个接口,定义如下:
public interface Lock {
void lock();
void lockInterruptibly() throws InterruptedException;
boolean tryLock();
boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
void unlock();
Condition newCondition();
}
方法 | 说明 |
---|---|
lock() | 获取锁,如果锁被其他线程占用了,就等待 |
tryLock() | 尝试获取锁,如果获取成功就返回true,如果获取失败,就返回false,这个不同于lock(),tryLock(),获取不到锁也会立即返回,而不是等待 |
unlock() | 释放锁,因为锁不会自动释放,所以通常将unlock()方法放到finally里,以保证肯定会被释放掉 |
2、ReadWriteLock
ReadWriteLock是一个接口,它定义了读锁和写锁,可以使得多个线程可以同时读。定义如下:
public interface ReadWriteLock {
Lock readLock();
Lock writeLock();
}
3、ReentrantReadWriteLock
ReentrantReadWriteLock是个类,它实现了ReadWriteLock接口。在应用读锁和写锁时候,如果一个线程占用了写锁,那么其他线程不能获取写锁也不能占用读锁,只有写完其他线程才能读和写,当一个线程占用了读锁,那么其他线程可以获取读锁,但是不能占用写锁,也就是只能读不能写。这样就比synchronized提高了读取时候的效率,因为synchronized作用下,不管读取还是写入,都必须一个线程一个线程地进行。
下面是一个ReentrantReadWriteLock的应用实例,模拟多个客户端对同一个银行账号进行操作,操作有:存钱、取钱、查询余额,保证存钱和取钱这两个写操作不能同时进行,但是在没有写入的时候,多个查询余额操作可以同时进行。
package lock;
import java.util.Date;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
/**
* Created by 鸣宇淳 on 2017/12/19.
* 多客户端对银行账号进行存取查询的例子
*/
public class MyLockDemo {
public static void main(String[] args) throws InterruptedException {
//创建银行账户
Account account = new Account("6222022222212154578", 1000);
//创建一个锁
ReadWriteLock lock = new ReentrantReadWriteLock(false);
//三个客户端同时操作
Client client1 = new Client("存钱1", 1, account, 500, lock);
Client client2 = new Client("取钱2", 2, account, 800, lock);
Client client3 = new Client("查询3", 3, account, 0, lock);
Client client4 = new Client("查询4", 3, account, 0, lock);
Client client5 = new Client("存钱5", 1, account, 100, lock);
Thread t1 = new Thread(client1);
Thread t2 = new Thread(client2);
Thread t3 = new Thread(client3);
Thread t4 = new Thread(client4);
Thread t5 = new Thread(client5);
System.out.println(new Date() + "账户内起始金额为1000\n---------------");
t1.start();
t2.start();
t3.start();
t4.start();
t5.start();
}
}
package lock;
import java.util.Date;
import java.util.concurrent.locks.ReadWriteLock;
/**
* Created by 鸣宇淳 on 2017/12/19.、
* 存取客户端
*/
public class Client implements Runnable {
private String name; //客户端操作人
private int saveOrWithdrawOrGet;//1.存钱 2.取钱 3.查询余额
private ReadWriteLock lock;//锁
private Account account;//操作账号
private int num;//存取金额
public Client(String name, int saveOrWithdrawOrGet, Account account, int num, ReadWriteLock lock) {
this.name = name;
this.saveOrWithdrawOrGet = saveOrWithdrawOrGet;
this.lock = lock;
this.account = account;
this.num = num;
}
public void run() {
if (this.saveOrWithdrawOrGet == 1) {
//存钱
try {
System.out.println(new Date() +this.name + "to....申请锁存钱");
lock.writeLock().lock();
int r = account.saveMoney(this.num);
System.out.println(new Date() +this.name + "存钱" + this.num + ",余额为" + r);
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.writeLock().unlock();
}
} else if (this.saveOrWithdrawOrGet == 2) {
//取钱
try {
System.out.println(new Date() +this.name + "to....申请锁取钱");
lock.writeLock().lock();
int r = account.withdrawMoney(num);
System.out.println(new Date() + this.name + "取钱" + this.num + ",余额为" + r);
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.writeLock().unlock();
}
} else if (this.saveOrWithdrawOrGet == 3) {
//查询余额
try {
System.out.println(new Date() +this.name + "to....申请锁查询");
lock.readLock().lock();
int r = account.getMoney();
System.out.println(new Date() +this.name + "查询余额,余额为" + r);
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.readLock().unlock();
}
}
}
}
package lock;
/**
* Created by 鸣宇淳 on 2017/12/19.
* 银行账户
*/
public class Account {
private String cardcode;
private int money;
public Account(String cardcode, int money) {
this.cardcode = cardcode;
this.money = money;
}
//存钱
public int saveMoney(int num) {
this.money = this.money + num;
return this.money;
}
//取钱
public int withdrawMoney(int num) {
if (num <= this.money) {
this.money = this.money - num;
}
return this.money;
}
//查询余额
public int getMoney() {
return this.money;
}
}
运行以上代码,输入如下:
Thu Dec 28 11:09:22 CST 2017账户内起始金额为1000
---------------
Thu Dec 28 11:09:22 CST 2017取钱2to....申请锁取钱
Thu Dec 28 11:09:22 CST 2017存钱5to....申请锁存钱
Thu Dec 28 11:09:22 CST 2017查询3to....申请锁查询
Thu Dec 28 11:09:22 CST 2017查询4to....申请锁查询
Thu Dec 28 11:09:22 CST 2017存钱1to....申请锁存钱
Thu Dec 28 11:09:22 CST 2017存钱5存钱100,余额为1100
Thu Dec 28 11:09:24 CST 2017取钱2取钱800,余额为300
Thu Dec 28 11:09:26 CST 2017查询3查询余额,余额为300
Thu Dec 28 11:09:26 CST 2017查询4查询余额,余额为300
Thu Dec 28 11:09:28 CST 2017存钱1存钱500,余额为800
通过输出可以看到,客户端12345同时申请各自的锁,存储5客户端11:09:22首先抢到了写锁,进行存钱操作后休眠了2秒,这个过程中,其他线程不管是申请写锁或者读锁,都不能得到锁,2秒后11:09:24取钱2客户端抢到了写锁,进程取钱操作后,休眠2秒,这个过程中同样其他线程不能读也不能写,11:09:26查询3客户端得到读锁,然后也休眠2秒,这个过程,查询4可以得到赌说,但是存钱1不能得到写锁,也就是只能读不能写,只有当2秒后,查询3和查询4都释放了读锁后,存钱1才能抢到写锁,进行存钱操作。