显示锁Lock
Lock接口
主要方法:
Lock与 synchronized的比较
synchronized 代码简洁（关键字，是属于语言层面实现同步）
Lock：获取锁可以被中断，超时获取锁，尝试获取锁，读多写少用读写锁(是JDK提供的一个接口，来实现同步)
可重入锁ReentrantLock
public class LockDemo {
static Lock lock = new ReentrantLock();
static int count;
public void increase(int num){
lock.lock();//获取锁
try{
count = count + num;
}finally {
lock.unlock();
}
}
public synchronized void increase_syn(int num){
count = count + num;
}
//synchronized方法调用另一个synchronized方法,可重入锁，释放锁时，一个一个释放
public synchronized void syn2(int num){
increase_syn(num);
}
}
公平锁和非公平锁
如果在时间上，先对锁进行获取的请求，一定先被满足，这个锁就是公平的，不满足，就是非公平的
非公平的效率一般来讲更高
ReentrantLock默认非公平锁
ReadWriteLock
实现类:ReentrantReadWriteLock
同一时刻允许多个读线程同时访问，但是写线程访问的时候，所有的读和写都被阻塞
示例：ReentrantReadWriteLock 与 synchronized的对比
public class GoodServiceLock implements GoodService{
private ReadWriteLock lock = new ReentrantReadWriteLock();
private Lock readLock = lock.readLock();
private Lock writeLock = lock.writeLock();
private GoodInfo goodInfo;
public GoodServiceLock(GoodInfo goodInfo){
this.goodInfo = goodInfo;
}
@Override
public GoodInfo getNum() {
readLock.lock();
try {
try {
Thread.sleep(5);
} catch (InterruptedException e) {
e.printStackTrace();
}
return goodInfo;
}finally {
readLock.unlock();
}
}
@Override
public void setNum(int number) {
writeLock.lock();
try {
try {
Thread.sleep(5);
} catch (InterruptedException e) {
e.printStackTrace();
}
goodInfo.changeNumber(number);
}finally {
writeLock.unlock();
}
}
}
public class GoodServiceSyn implements GoodService{
private GoodInfo goodInfo;
public GoodServiceSyn(GoodInfo goodInfo){
this.goodInfo = goodInfo;
}
@Override
public synchronized GoodInfo getNum() {
try {
Thread.sleep(5);
} catch (InterruptedException e) {
e.printStackTrace();
}
return this.goodInfo;
}
@Override
public synchronized void setNum(int number) {
try {
Thread.sleep(5);
} catch (InterruptedException e) {
e.printStackTrace();
}
goodInfo.changeNumber(number);
}
}
public class GoodTest {
private static int writeNum = 2;
private static int readNum = 5;
static class ReadGoodThread extends Thread {
private GoodService goodService;
public ReadGoodThread(GoodService goodService) {
this.goodService = goodService;
}
@Override
public void run() {
long start = System.currentTimeMillis();
for (int i = 0; i < 100; i++) {//操作100次
goodService.getNum();
}
System.out.println(Thread.currentThread().getName() + "读取商品数据耗时："
+ (System.currentTimeMillis() - start) + "ms");
}
}
static class WriteGoodThread extends Thread {
private GoodService goodService;
public WriteGoodThread(GoodService goodService) {
this.goodService = goodService;
}
@Override
public void run() {
long start = System.currentTimeMillis();
Random r = new Random();
for (int i = 0; i < 10; i++) {//操作10次
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
goodService.setNum(r.nextInt(10));
}
System.out.println(Thread.currentThread().getName()
+ "写商品数据耗时：" + (System.currentTimeMillis() - start) + "ms---------");
}
}
public static void main(String[] args) {
GoodInfo goodInfo = new GoodInfo(100000, 10000);
GoodService goodsService = new GoodServiceSyn(goodInfo);
// GoodService goodsService = new GoodServiceLock(goodInfo);
for (int i = 0; i < writeNum; i++) {
Thread setT = new Thread(new WriteGoodThread(goodsService));
for (int j = 0; j < readNum; j++) {
Thread getT = new Thread(new ReadGoodThread(goodsService));
getT.start();
}
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
setT.start();
}
}
}运行结果:
synchronized:
Thread-23读取商品数据耗时：3112ms
Thread-7读取商品数据耗时：3655ms
Thread-19读取商品数据耗时：3749ms
Thread-9读取商品数据耗时：4055ms
Thread-21读取商品数据耗时：4033ms
Thread-11读取商品数据耗时：4195ms
Thread-15读取商品数据耗时：4330ms
Thread-17读取商品数据耗时：4820ms
Thread-1写商品数据耗时：4864ms---------
Thread-5读取商品数据耗时：5116ms
Thread-3读取商品数据耗时：5133ms
Thread-13写商品数据耗时：4991ms---------ReentrantReadWriteLock :
Thread-5读取商品数据耗时：589ms
Thread-3读取商品数据耗时：595ms
Thread-11读取商品数据耗时：594ms
Thread-9读取商品数据耗时：608ms
Thread-7读取商品数据耗时：614ms
Thread-1写商品数据耗时：605ms---------
Thread-21读取商品数据耗时：614ms
Thread-19读取商品数据耗时：619ms
Thread-15读取商品数据耗时：641ms
Thread-23读取商品数据耗时：639ms
Thread-17读取商品数据耗时：649ms
Thread-13写商品数据耗时：589ms---------在读多写少的场景下，可以看出ReentrantReadWriteLock比synchronized的效率高出很多。
Condition
用Lock与Condition实现消息通知(类似与Obejct的wait、notify、notifyAll，但比这个更优，不会出现信号丢失的现象，一个Lock可以创建多个Condition，根据Condition的不同，分别进行await，signal、signalAll)
public class ConditionDemo {
static String CITY = "xianyang";
static Lock lock = new ReentrantLock();
static Condition siteCondition = lock.newCondition();
static Condition kmCondition = lock.newCondition();
private String site;
private int km;
public ConditionDemo(String site, int km) {
this.site = site;
this.km = km;
}
/* 变化公里数，然后通知处于wait状态并需要处理公里数的线程进行业务处理*/
public void changeKm(){
lock.lock();
try {
this.km = 101;
kmCondition.signal();
}finally {
lock.unlock();
}
}
/* 变化地点，然后通知处于wait状态并需要处理地点的线程进行业务处理*/
public void changeSite(){
lock.lock();
try {
this.site = "BeiJing";
siteCondition.signal();
}finally {
lock.unlock();
}
}
/*当快递的里程数大于100时更新数据库*/
public void waitKm(){
lock.lock();
try {
while(this.km<=100) {
try {
kmCondition.await();
System.out.println("check km thread["+Thread.currentThread().getId()
+"] is be notifed.");
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}finally {
lock.unlock();
}
System.out.println("the Km is "+this.km+",I will change db");
}
/*当快递到达目的地时通知用户*/
public void waitSite(){
lock.lock();
try {
while(CITY.equals(this.site)) {
try {
siteCondition.await();
System.out.println("check site thread["+Thread.currentThread().getId()
+"] is be notifed.");
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}finally {
lock.unlock();
}
System.out.println("the site is "+this.site+",I will call user");
}
}
运行结果:
check km thread[11] is be notifed.
the Km is 101,I will change db
check site thread[15] is be notifed.
the site is BeiJing,I will call user
check site thread[16] is be notifed.
the site is BeiJing,I will call user
check km thread[12] is be notifed.
the Km is 101,I will change db根据结果可知，Condition可以单独唤醒某一个或一类的线程。