JVM锁

一、synchronized关键字

1、synchronized的本质

本质上就是在代码块或者方法执行的首尾行添加了两条指令:monitorenter和monitorexit

monitorenter:对象的锁计数加1
monitorexit：对象的锁计数减1

每个对象的都对应一个监视器锁（monitor）对象,
当monitor被占用(大于1)时就会处于锁定状态,其它线程不能访问。

在获取对象锁的时候(获取cpu执行权的时候),就调用monitorenter,对象锁加1,此时锁大于0,
则其他线程不能访问。
调用完成或者发生异常就释放锁,就会调用monitorenter减去1。

Synchronized的语义底层是通过操作一个monitor的对象来完成，
wait/notify等方法也依赖于monitor对象，
这就是为什么只有在同步的块或者方法中才能调用wait/notify等方法，
否则会抛出java.lang.IllegalMonitorStateException的异常的原因。

总结:

在执行代码的首尾行添加两条指令做对象监控锁的加1和减1操作,当监控锁(monitor)大于1时,
其它线程是访问不了当前对象的。

线程的等待唤醒等操作,也是依赖于锁住的对象对应的监控锁(monitor)，
对monitor进行加1减1操作,所以只有在同步的块或者方法中才能调用wait/notify等方法，
否则会抛出java.lang.IllegalMonitorStateException的异常。

二、synchronized修饰方法或代码块

1、synchronized加在静态方法上,锁住的是当前类,其它线程访问当前类的每个实例的
    所有方法，都会阻塞。

2、synchronized加在成员方法上,锁住的是本实例,其它线程访问本实例的所有方法,都会阻塞。

3、synchronized加在代码块上,锁住的是代码块的代码。

4、synchronized也可以锁住一个特定的对象,比如:this/其它某个单独的对象实例/类等。

5、非static synchronized方法和static synchronized方法,不会发生互斥,因为一个是实例锁
     一个是类锁。

三、synchronized的缺陷

1、只有在完成任务和发生异常的情况下，才能释放锁,如果当前线程任务一直阻塞,
     当前线程将释放不了锁。

2、读写锁不能分离,读写和写写是影响线程安全的,但是读读之间是不影响安全的。
    这就导致了,一段代码里面,有读和写的逻辑,不同线程之间读的操作也要同步,
   不能多线程并发执行。

3、无法判断是否获取了锁。

四、lock接口

1、lock的优点

(1)、lock可以手动释放锁和中断阻塞状态的锁(lockInterruptibly())。

(2)、lock可以拆分成读写锁,实现不同线程之间读操作不锁,
不同线程之间的写操作锁住,不同线程之间读和写锁住。

(3)、可以提供trylock方法判断否获取了锁。

(4)、lock提供了比synchronized更多的功能,lock不会主动释放锁,要注意手动释放锁。

2、lock的方法

<1>、获取锁：

lock()/tryLock()/tryLock(long time, TimeUnit unit)/lockInterruptibly()

当通过lockInterruptibly()方法获取某个锁时，
如果不能获取到,在线程等待的情况下,是可以响应中断的。

tryLock是可以返回boolean值,并且指定具体的获取时间

<2>、释放锁:

unLock()方法

<3>、手动执行等待或唤醒

new 一个Condition对象,调用其方法。

<4>、中断线程

interrupt()方法,不能中断正在运行过程中的线程，只能中断阻塞过程中的线程。

两个线程都使用lockInterruptibly获取锁，如果线程A获取到了锁，线程B只能等待，
对线程B调用interrupt()方法能够中断线程B的等待过程。(获取不到就中断,不获取了)

3、reentrantLock

ReentrantLock是唯一实现了Lock接口的类，并且ReentrantLock提供了更多的
方法。

4、reentrantReadWriteLock

readLock()和writeLock()用来获取读锁和写锁。实际上就是把读和写锁分开,
读写互斥、写写互斥。

5、lock和synchronized的选择

<1>、Lock是一个接口，而synchronized是Java中的关键字，
   	 synchronized是内置的语言实现；

<2>、synchronized在发生异常时，会自动释放线程占有的锁，
     因此不会导致死锁现象发生；

     而Lock在发生异常时，如果没有主动通过unLock()去释放锁，
     则很可能造成死锁现象，
     因此使用Lock时需要在finally块中释放锁；

<3>、Lock可以让等待锁的线程响应中断，而synchronized却不行，
	 使用synchronized时，等待的线程会一直等待下去，不能够响应中断；

<4>、通过Lock可以知道有没有成功获取锁，而synchronized却无法办到。

<5>、Lock可以提高多个线程进行读操作的效率。

<6>、Lock可以提高多个线程进行读操作的效率。

	在性能上来说，如果竞争资源不激烈，两者的性能是差不多的，
	而当竞争资源非常激烈时（即有大量线程同时竞争）,
	特别是读操作比较多的情况下，此时Lock的性能要远远优于synchronized。

五、锁的相关概念

1.可重入锁:

锁的分配机制,基于线程的分配，而不是基于方法调用的分配。
就是不管一个线程内有多少个锁,只要获取了外层的锁,就不用再获取其它锁了。
synchronized和ReentrantLock都是可重入锁。

锁不可重入,可能会造成当前线程获取某个锁之后,执行相应的逻辑,
但是内部其它锁没有获取,执行不了,导致外层的锁释放不了。

2、可中断锁

synchronized就不是可中断锁，而Lock是可中断锁。

tryLock:

如果某一线程A正在执行锁中的代码，另一线程B正在等待获取该锁，可
能由于等待时间过长，线程B不想等待了，想先处理其他事情。

lockInterruptibly:

用这种方式获取的锁,可以手动执行interrupt()方法,
在当前线程等待的时候,中断该线程。

3、公平锁

公平锁即尽量以请求锁的顺序来获取锁。
比如同是有多个线程在等待一个锁，当这个锁被释放时，等待时间最久的线程
（最先请求的线程）会获得该所，这种就是公平锁。

synchronized就是非公平锁，它无法保证等待的线程获取锁的顺序。
而对于ReentrantLock和ReentrantReadWriteLock，
它默认情况下是非公平锁，但是可以设置为公平锁。

ReentrantLock lock = new ReentrantLock(true);
如果参数为true表示为公平锁，为fasle为非公平锁。默认情况下，
如果使用无参构造器，则是非公平锁。

4、读写锁

读写锁将对一个资源（比如文件）的访问分成了2个锁，
一个读锁和一个写锁。

ReadWriteLock就是读写锁，它是一个接口，
ReentrantReadWriteLock实现了这个接口。