Java多线程-锁的区别与使用

目录

• 锁类型
  • 可中断锁
  • 公平锁/非公平锁
  • 可重入锁
  • 独享锁/共享锁
  • 互斥锁/读写锁
  • 乐观锁/悲观锁
  • 分段锁
  • 偏向锁/轻量级锁/重量级锁
  • 自旋锁
• Synchronized与Static Synchronized
  • 举例
• Lock
  • 定义
  • 四种获取Lock的方法区别
    • lock()
    • tryLock()
    • tryLock(long time, TimeUnit unit)
    • lockInterruptibly()
• synchronized与Lock的区别

锁类型

可中断锁

• 在等待获取锁过程当中可中断
• Lock就是可中断锁

公平锁/非公平锁

• 公平锁是指多个线程按照申请锁的顺序来获取锁。
• 非公平锁是指多个线程获取锁的顺序并非按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获取锁。有可能，会形成优先级反转或者饥饿现象。
• 对于ReentrantLock而言，经过构造函数指定该锁是不是公平锁，默认是非公平锁。非公平锁的优势在于吞吐量比公平锁大。
• 对于Synchronized而言，也是一种非公平锁。因为其并不像ReentrantLock是经过AQS的来实现线程调度，因此并无任何办法使其变成公平锁。

可重入锁

• 可重入锁又名递归锁，是指在同一个线程在外层方法获取锁的时候，在进入内层方法会自动获取锁。
• 对于Java ReentrantLock而言, 他的名字就能够看出是一个可重入锁，其名字是Re entrant Lock从新进入锁。
• 对于Synchronized而言,也是一个可重入锁。可重入锁的一个好处是可必定程度避免死锁。

synchronized void setA() throws Exception{
 
    Thread.sleep(1000);
 
    setB();
 
}
 
synchronized void setB() throws Exception{
 
    Thread.sleep(1000);
 
}

独享锁/共享锁

• 独享锁是指该锁一次只能被一个线程所持有。
• 共享锁是指该锁可被多个线程所持有。
• 对于Java ReentrantLock而言，其是独享锁。可是对于Lock的另外一个实现类ReadWriteLock，其读锁是共享锁，其写锁是独享锁。
• 读锁的共享锁可保证并发读是很是高效的，读写，写读 ，写写的过程是互斥的。
• 独享锁与共享锁也是经过AQS来实现的，经过实现不一样的方法，来实现独享或者共享。
• Synchronized是独享锁。

互斥锁/读写锁

• 上面讲的独享锁/共享锁就是一种广义的说法，互斥锁/读写锁就是具体的实现。
• 互斥锁在Java中的具体实现就是ReentrantLock
• 读写锁在Java中的具体实现就是ReadWriteLock

乐观锁/悲观锁

• 乐观锁与悲观锁不是指具体的什么类型的锁，而是指看待并发同步的角度。
• 悲观锁认为对于同一个数据的并发操做，必定是会发生修改的，哪怕没有修改，也会认为修改。所以对于同一个数据的并发操做，悲观锁采起加锁的形式。悲观的认为，不加锁的并发操做必定会出问题。
• 乐观锁则认为对于同一个数据的并发操做，是不会发生修改的。在更新数据的时候，会采用尝试更新，不断从新的方式更新数据。乐观的认为，不加锁的并发操做是没有事情的。
• 从上面的描述咱们能够看出，悲观锁适合写操做很是多的场景，乐观锁适合读操做很是多的场景，不加锁会带来大量的性能提高。
• 悲观锁在Java中的使用，就是利用各类锁。
• 乐观锁在Java中的使用，是无锁编程，经常采用的是CAS算法，典型的例子就是原子类，经过CAS自旋实现原子操做的更新。

分段锁

• 分段锁实际上是一种锁的设计，并非具体的一种锁，对于ConcurrentHashMap而言，其并发的实现就是经过分段锁的形式来实现高效的并发操做。
• 分段锁的设计目的是细化锁的粒度，当操做不须要更新整个数组的时候，就仅仅针对数组中的一项进行加锁操做。

偏向锁/轻量级锁/重量级锁

• 这三种锁是指锁的状态，而且是针对Synchronized。在Java 5经过引入锁升级的机制来实现高效Synchronized。这三种锁的状态是经过对象监视器在对象头中的字段来代表的。
• 偏向锁是指一段同步代码一直被一个线程所访问，那么该线程会自动获取锁。下降获取锁的代价。
• 轻量级锁是指当锁是偏向锁的时候，被另外一个线程所访问，偏向锁就会升级为轻量级锁，其余线程会经过自旋的形式尝试获取锁，不会阻塞，提升性能。
• 重量级锁是指当锁为轻量级锁的时候，另外一个线程虽然是自旋，但自旋不会一直持续下去，当自旋必定次数的时候，尚未获取到锁，就会进入阻塞，该锁膨胀为重量级锁。重量级锁会让其余申请的线程进入阻塞，性能下降。

自旋锁

• 自旋锁原理很是简单，若是持有锁的线程能在很短期内释放锁资源，那么那些等待竞争锁的线程就不须要作内核态和用户态之间的切换进入阻塞挂起状态，它们只须要等一等（自旋），等持有锁的线程释放锁后便可当即获取锁，这样就避免用户线程和内核的切换的消耗。
• 可是线程自旋是须要消耗cup的，说白了就是让cup在作无用功，若是一直获取不到锁，那线程也不能一直占用cup自旋作无用功，因此须要设定一个自旋等待的最大时间。
• 若是持有锁的线程执行的时间超过自旋等待的最大时间扔没有释放锁，就会致使其它争用锁的线程在最大等待时间内仍是获取不到锁，这时争用线程会中止自旋进入阻塞状态。

Synchronized与Static Synchronized

区别

• static synchronized方法是类锁，synchronized方法是对象锁

• synchronized至关于 this.synchronized，static synchronized至关于Something.synchronized

举例

pulbic class Test(){
    public synchronized void A(){}
    public synchronized void B(){}
    public static synchronized void cA(){}
    public static synchronized void cB(){}
}

新建两个实例，x和y

1 x.A()与x.B() 
2 x.A()与y.A()
3 x.cA()与y.cB()
4 x.A()与Test.cA()

四种状况哪组方法何以被多个以上线程同时访问？

• 状况1：同一个实例上锁确定不行
• 状况2：是针对不一样实例的，所以能够同时被访问
• 状况3：由于static synchronized为类锁，因此不一样实例之间仍然会被限制
• 状况4：能够，类锁和实例锁互不干扰

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()、tryLock(long time, TimeUnit unit)和lockInterruptibly()是用来获取锁的。
• unLock()方法是用来释放锁的。

四种获取Lock的方法区别

lock()

日常使用得最多的一个方法，就是用来获取锁。若是锁已被其余线程获取，则进行等待。

使用Lock必须在try{}catch{}块中进行，而且将释放锁的操做放在finally块中进行，以保证锁必定被被释放，防止死锁的发生。

Lock lock = ...;
lock.lock();
try{
    //处理任务
}catch(Exception ex){
     
}finally{
    lock.unlock();   //释放锁
}

tryLock()

tryLock()有返回值的，它表示用来尝试获取锁，若是获取成功，则返回true，若是锁已被其余线程获取，则返回false。

这个方法会当即返回，在拿不到锁时也不会一直在那等待。

Lock lock = ...;
if(lock.tryLock()) {
     try{
         //处理任务
     }catch(Exception ex){
         
     }finally{
         lock.unlock();   //释放锁
     } 
}else {
    //若是不能获取锁，则直接作其余事情
}

tryLock(long time, TimeUnit unit)

此方法在拿不到锁时会等待必定的时间，在时间期限以内若是还拿不到锁，就返回false。若是若是一开始拿到锁或者在等待期间内拿到了锁，则返回true。

lockInterruptibly()方法比较特殊，当经过这个方法去获取锁时，若是线程正在等待获取锁，则这个线程可以响应中断，即中断线程的等待状态。也就使说，当两个线程同时经过lock.lockInterruptibly()想获取某个锁时，倘若此时线程A获取到了锁，而线程B还在等待，那么对线程B调用threadB.interrupt()方法中断线程B的等待过程。

lockInterruptibly()

当经过lockInterruptibly()方法获取某个锁时，若是不能获取到，只有进行等待的状况下，是能够响应中断的。

而用synchronized修饰的话，当一个线程处于等待某个锁的状态，是没法被中断的，只有一直等待下去。

当一个线程获取了锁以后，是不会被interrupt()方法中断的。单独调用interrupt()方法不能中断正在运行过程当中的线程，只能中断阻塞过程当中的线程。

lockInterruptibly()的声明中抛出了异常，因此lock.lockInterruptibly()必须放在try块中或者在调用lockInterruptibly()的方法外声明抛出InterruptedException。

public void method() throws InterruptedException {
    lock.lockInterruptibly();
    try {  
     //.....
    }
    finally {
        lock.unlock();
    }  
}

synchronized与Lock的区别