定义:
隐式锁(Synchronized)是Java的关键字,当它用来修饰一个方法或一个代码块时,能够保证在同一时刻最多只有一个线程执行该代码。因为当调用Synchronized修饰的代码时,并不需要显示的加锁和解锁的过程,所以是隐式锁。
显示锁(Lock)是一个接口,提供了无条件的、可轮询的、定时的、可中断的锁获取操作,所有的加锁和解锁操作方法都是显示的,因而称为显示锁。
区别:
1.出生不同:
synchronized:Java中的关键字,是由JVM来维护的。是JVM层面的锁。
Lock:是JDK5以后才出现的具体的类。使用lock是调用对应的API。是API层面的锁。
synchronized是底层是通过monitorenter进行加锁(底层是通过monitor对象来完成的,其中的wait/notify等方法也是依赖于monitor对象的。只有在同步块或者是同步方法中才可以调用wait/notify等方法的。因为只有在同步块或者是同步方法中,JVM才会调用monitory对象的);通过monitorexit来退出锁的。而lock是通过调用对应的API方法来获取锁和释放锁的。
2.使用方式不同:
synchronized是隐式锁。Lock是显示锁
所谓的显示和隐式就是在使用的时候,使用者要不要手动写代码去获取锁和释放锁的操作。
我们大家都知道,在使用synchronized关键字的时候,我们使用者根本不用写其他的代码,然后程序就能够获取锁和释放锁了。那是因为当synchronized代码块执行完成之后,系统会自动的让程序释放占用的锁。synchronized是由系统维护的,如果非逻辑问题的话话,是不会出现死锁的。
在使用lock的时候,我们使用者需要手动的获取和释放锁。如果没有释放锁,就有可能导致出现死锁的现象。手动获取锁方法:lock.lock()。释放锁:unlock方法。需要配合tyr/finaly语句块来完成。
两者用法如下:
隐式锁
public class Demo1 {
public static void main(String[] args){
MySucrity mySucrity = new MySucrity();
new Thread(mySucrity).start();
new Thread(mySucrity).start();
new Thread(mySucrity).start();
}
static class MySucrity implements Runnable{
private int count=10;
private Object o=new Object();
@Override
public void run() {
while(true){
synchronized(o){
if(count>0){
System.out.println("正在输出");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
count--;
System.out.println(Thread.currentThread().getName()+"余票:"+count);
}else{
break;
}
}
}
}
}
}
public class Demo2 {
public static void main(String[] args){
Mysucrity mySucrity = new Mysucrity();
new Thread(mySucrity).start();
new Thread(mySucrity).start();
new Thread(mySucrity).start();
}
static class Mysucrity implements Runnable {
private int count = 10;
@Override
public void run() {
while(true){
boolean sale = sale();
if(!sale){
break;
}
}
}
public synchronized boolean sale() {
if (count > 0) {
System.out.println("正在输出");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
count--;
System.out.println(Thread.currentThread().getName() + "余票:" + count);
return true;
}else{
return false;
}
}
}
}
显示锁:
public class Demo3 {
public static void main(String[] args){
Myucrity mySucrity = new Myucrity();
new Thread(mySucrity).start();
new Thread(mySucrity).start();
new Thread(mySucrity).start();
}
static class Myucrity implements Runnable{
private int count=10;
private Lock l=new ReentrantLock();
@Override
public void run() {
while(true){
l.lock();
if(count>0){
System.out.println("正在输出");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
count--;
System.out.println(Thread.currentThread().getName()+"余票:"+count);
}else{
break;
}
l.unlock();
}
}
}
}
3.等待是否可中断
synchronized是不可中断的。除非抛出异常或者正常运行完成
Lock可以中断的。中断方式:
(1):调用设置超时方法tryLock(long timeout ,timeUnit unit)
(2):调用lockInterruptibly()放到代码块中,然后调用interrupt()方法可以中断
4.加锁的时候是否可以公平
synchronized;非公平锁
lock:两者都可以的。默认是非公平锁。在其构造方法的时候可以传入Boolean值。
true:公平锁
false:非公平锁
5.能否精准唤醒
Synchronized: 不能精准唤醒,要么随机唤醒一个线程;要么是唤醒所有等待的线程。
Lock: 用来实现分组唤醒需要唤醒的线程,可以精确的唤醒,而不是像Synchronized那样,不能精确唤醒线程。
6.性能比较
Synchronized是托管给JVM执行的,而Lock是Java写的控制锁的代码。
在Java1.5中,Synchronized是性能低效的。因为这是一个重量级操作,需要调用操作接口,导致有可能加锁消耗的系统时间比加锁以外的操作还多。相比之下使用Java提供的Lock对象,性能更高一些。
但是到了Java1.6版本,发生了变化。Synchronized在语义上很清晰,可以进行很多优化,实现了许多以前没有的操作,Synchronized的性能这个时候并不比Lock性能差.