一、Lock
Lock接口的方法:
- lock():获取锁,如果锁被暂用则一直等待
-
unlock():释放锁
-
tryLock():注意返回类型是boolean,仅在调用时锁未被另一个线程保持的情况下,才获取该锁。如果锁被占用,则直接返回
-
tryLock(long time, TimeUnit unit):比起tryLock()就是给了一个时间期限,保证等待参数时间
-
lockInterruptibly():用该锁的获得方式,如果线程在获取锁的阶段进入了等待,那么可以中断此线程,先去做别的事
可重入锁
可重入锁意味着,线程可以进入任何一个它已经拥有的锁所同步着的代码块。Sychronized是可重入锁,Lock可选择是否可重入。
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
响应中断
线程因为等待获取Sychronized或普通Lock锁而引起阻塞时,是不能响应中断的(即调用interrupt()无法抛出异常,不影响阻塞状态)。但通过lock.lockInterruptibly()方法获取的锁可以响应中断。
class Syn{
Lock lock=new ReentrantLock();
public void get(){
try{
//普通锁
lock.lock();
System.out.println(Thread.currentThread().getName());
Thread.sleep(5*1000);
}catch (InterruptedException e){
e.printStackTrace();
}finally {
lock.unlock();
}
}
}
public class ThreadTest extends Thread {
Syn s;
public ThreadTest(Syn s,String name){
this.s=s;
this.setName(name);
}
@Override
public void run() {
super.run();
s.get();
}
public static void main(String[] args) {
Syn s=new Syn();
ThreadTest t1=new ThreadTest(s,"t1");
ThreadTest t2=new ThreadTest(s,"t2");
try{
t1.start();
Thread.sleep(1000);
t2.start();
Thread.sleep(1000);
//此时t2处于等待获取锁的阻塞状态
t2.interrupt();
}catch (Exception e){
e.printStackTrace();
}
}
}
结果:
t1
t2
class Syn{
Lock lock=new ReentrantLock();
public void get(){
try{
//可中断锁
lock.lockInterruptibly();
System.out.println(Thread.currentThread().getName());
Thread.sleep(5*1000);
}catch (InterruptedException e){
e.printStackTrace();
}finally {
lock.unlock();
}
}
}
public class ThreadTest extends Thread {
Syn s;
public ThreadTest(Syn s,String name){
this.s=s;
this.setName(name);
}
@Override
public void run() {
super.run();
s.get();
}
public static void main(String[] args) {
Syn s=new Syn();
ThreadTest t1=new ThreadTest(s,"t1");
ThreadTest t2=new ThreadTest(s,"t2");
try{
t1.start();
Thread.sleep(1000);
t2.start();
Thread.sleep(1000);
t2.interrupt();
}catch (Exception e){
e.printStackTrace();
}
}
}
结果:
t1
java.lang.InterruptedException
at java.util.concurrent.locks.AbstractQueuedSynchronizer.doAcquireInterruptibly(AbstractQueuedSynchronizer.java:898)
at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireInterruptibly(AbstractQueuedSynchronizer.java:1222)
at java.util.concurrent.locks.ReentrantLock.lockInterruptibly(ReentrantLock.java:335)
at algorithm.Syn.get(ThreadTest.java:13)
at algorithm.ThreadTest.run(ThreadTest.java:32)
Exception in thread "t2" java.lang.IllegalMonitorStateException
at java.util.concurrent.locks.ReentrantLock$Sync.tryRelease(ReentrantLock.java:151)
at java.util.concurrent.locks.AbstractQueuedSynchronizer.release(AbstractQueuedSynchronizer.java:1261)
at java.util.concurrent.locks.ReentrantLock.unlock(ReentrantLock.java:457)
at algorithm.Syn.get(ThreadTest.java:19)
at algorithm.ThreadTest.run(ThreadTest.java:32)
Process finished with exit code 0
Lock的实现
- ReentrantLock
- ReentrantReadWriteLock
- StampedLock
ReentrantReadWriteLock读写锁:
读写分离,即,读读共享、写写互斥、读写互斥。同时还支持一下功能:
- 支持公平和非公平的获取锁的方式;
- 支持可重入。读线程在获取了读锁后还可以获取读锁;写线程在获取了写锁之后既可以再次获取写锁又可以获取读锁;
- 还允许从写入锁降级为读取锁,其实现方式是:先获取写入锁,然后获取读取锁,最后释放写入锁。但是,从读取锁升级到写入锁是不允许的;
https://www.cnblogs.com/zaizhoumo/p/7782941.html
https://blog.youkuaiyun.com/fxkcsdn/article/details/82217760
二、Synchronized
自旋锁
自旋锁原理非常简单,如果持有锁的线程能在很短时间内释放锁资源,那么那些等待竞争锁的线程就不需要做内核态和用户态之间的切换进入阻塞挂起状态,它们只需要等一等(自旋),等持有锁的线程释放锁后即可立即获取锁,这样就避免用户线程和内核的切换的消耗。
但是线程自旋是需要消耗cup的,说白了就是让cup在做无用功,如果一直获取不到锁,那线程也不能一直占用cup自旋做无用功,所以需要设定一个自旋等待的最大时间。
如果持有锁的线程执行的时间超过自旋等待的最大时间扔没有释放锁,就会导致其它争用锁的线程在最大等待时间内还是获取不到锁,这时争用线程会停止自旋进入阻塞状态。
偏向锁
偏向锁,顾名思义,它会偏向于第一个访问锁的线程,如果在运行过程中,同步锁只有一个线程访问,不存在多线程争用的情况,则线程是不需要触发同步的,这种情况下,就会给线程加一个偏向锁。 偏向锁通过消除资源无竞争情况下的同步原语,进一步提高了程序的运行性能。
如果在运行过程中,遇到了其他线程抢占锁,则持有偏向锁的线程会被挂起,JVM会消除它身上的偏向锁,将锁恢复到标准的轻量级锁。
偏向锁的获取过程:
- 访问Mark Word中偏向锁的标识是否设置成1,锁标志位是否为01,确认为可偏向状态。
- 如果为可偏向状态,则测试线程ID是否指向当前线程,如果是,进入步骤5,否则进入步骤3。
- 如果线程ID并未指向当前线程,则通过CAS操作竞争锁。如果竞争成功,则将Mark Word中线程ID设置为当前线程ID,然后执行5;如果竞争失败,执行4。
- 如果CAS获取偏向锁失败,则表示有竞争。当到达全局安全点(safepoint)时获得偏向锁的线程被挂起,偏向锁升级为轻量级锁,然后被阻塞在安全点的线程继续往下执行同步代码。(撤销偏向锁的时候会导致stop the word)
- 执行同步代码。
轻量级锁
轻量级锁是由偏向所升级来的,偏向锁运行在一个线程进入同步块的情况下,当第二个线程加入锁争用的时候,偏向锁就会升级为轻量级锁。
重量级锁
即传统意义上的Synchronized。
synchronized的执行过程
- 检测Mark Word里面是不是当前线程的ID,如果是,表示当前线程处于偏向锁
- 如果不是,则使用CAS将当前线程的ID替换Mard Word,如果成功则表示当前线程获得偏向锁,置偏向标志位1
- 如果失败,则说明发生竞争,撤销偏向锁,进而升级为轻量级锁。
- 当前线程使用CAS将对象头的Mark Word替换为锁记录指针,如果成功,当前线程获得锁
- 如果失败,表示其他线程竞争锁,当前线程便尝试使用自旋来获取锁。
- 如果自旋成功则依然处于轻量级状态。
- 如果自旋失败,则升级为重量级锁。
在所有的锁都启用的情况下线程进入临界区时会先去获取偏向锁,如果已经存在偏向锁了,则会尝试获取轻量级锁,启用自旋锁,如果自旋也没有获取到锁,则使用重量级锁,没有获取到锁的线程阻塞挂起,直到持有锁的线程执行完同步块唤醒他们;
偏向锁是在无锁争用的情况下使用的,也就是同步开在当前线程没有执行完之前,没有其它线程会执行该同步块,一旦有了第二个线程的争用,偏向锁就会升级为轻量级锁,如果轻量级锁自旋到达阈值后,没有获取到锁,就会升级为重量级锁;
如果线程争用激烈,那么应该禁用偏向锁。
https://blog.youkuaiyun.com/zqz_zqz/article/details/70233767
本文详细介绍了Lock和Synchronized两种锁机制。Lock接口有多种获取锁的方法,其实现包括ReentrantLock等,支持可重入和响应中断。Synchronized有自旋锁、偏向锁等类型,执行过程会根据竞争情况从偏向锁逐步升级到重量级锁,线程争用激烈时可禁用偏向锁。
2971

被折叠的 条评论
为什么被折叠?



