JAVA高性能编程(十):锁机制

x33g5p2x  于2020-09-30 发布在 Java  
字(4.1k)|赞(0)|评价(0)|浏览(514)

java并发 lock锁

synchronized的缺陷

一个代码块被synchronized修饰了,当一个线程获取了对应的锁,并执行该代码块时,其他线程便只能一直等待,等待获取锁的线程释放锁。

  1. 获取锁的线程发生阻塞(且没有释放锁),其他线程只能一直等待,等待获取锁的线程释放锁,影响执行效率。
  2. 当有多个线程读操作,一个线程在进行读操作,其他线程只能等待无法进行读操作。
    解决方案:使用Lock锁
    【注意】
  • Lock不是Java语言内置的,synchronized是Java语言的关键字,因此是内置特性。Lock是一个类,通过这个类可以实现同步访问;
  • synchronized无需手动释放锁,Lock必须手动释放锁,否则可能导致死锁
    synchronized方法或者synchronized代码块执行完之后,系统会自动让线程释放对锁的占用;Lock则必须要用户去手动释放锁,如果没有主动释放锁,就有可能导致出现死锁现象。

java中常用的锁

java.util.concurrent.locks包中常用的类和接口。Lock接口最为基础。

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();
}
  1. lock()最常用
Lock lock = ...;
lock.lock();
try{
    //处理任务 -- 业务逻辑
}catch(Exception ex){
     
}finally{
    lock.unlock();   //释放锁 -- 必须手动释放锁
}
  1. tryLock()

tryLock()方法是有返回值的,它表示用来尝试获取锁,如果获取成功,则返回true,如果获取失败(即锁已被其他线程获取),则返回false,也就说这个方法无论如何都会立即返回。在拿不到锁时不会一直在那等待。

Lock lock = ...;
if(lock.tryLock()) {
     try{
         //处理任务
     }catch(Exception ex){
         
     }finally{
         lock.unlock();   //释放锁
     } 
}else {
    //如果不能获取锁,则直接做其他事情
}
  1. tryLock(long time, TimeUnit unit)

tryLock(long time, TimeUnit unit)方法和tryLock()方法是类似的,只不过在拿不到锁时会等待一定的时间,在时间期限之内如果还拿不到锁,就返回false。

  1. lockInterruptibly()

 lockInterruptibly()方法比较特殊,当通过这个方法去获取锁时,如果线程正在等待获取锁,则这个线程能够响应中断,即中断线程的等待状态。也就使说,当两个线程同时通过lock.lockInterruptibly()想获取某个锁时,假若此时线程A获取到了锁,而线程B只有在等待,那么对线程B调用threadB.interrupt()方法能够中断线程B的等待过程。

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

【注意】
当一个线程获取了锁之后,是不会被interrupt()方法中断的。因为本身在前面的文章中讲过单独调用interrupt()方法不能中断正在运行过程中的线程,只能中断阻塞过程中的线程。

ReentrantLock

ReentrantLock,意思是“可重入锁”。
如果锁具备可重入性,则称作为可重入锁。像synchronized和ReentrantLock都是可重入锁,可重入性在我看来实际上表明了锁的分配机制:基于线程的分配,而不是基于方法调用的分配。举个简单的例子,当一个线程执行到某个synchronized方法时,比如说method1,而在method1中会调用另外一个synchronized方法method2,此时线程不必重新去申请锁,而是可以直接执行方法method2。

class MyClass {
    public synchronized void method1() {
        method2();
    }
     
    public synchronized void method2() {
         
    }
}

案例:

package com.eastlong.threadlearn.locklearn;
import java.util.ArrayList;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockDemo {
    Lock lock = new ReentrantLock(); // 全局lock变量
    private ArrayList<Integer> arrayList = new ArrayList<Integer>();


    public static void main(String[] args) {
        final LockDemo lockDemo = new LockDemo();
        new Thread(){
            public void run() {
                lockDemo.insert(Thread.currentThread());
            }
        }.start();

        new Thread(){
            public void run() {
                lockDemo.insert(Thread.currentThread());
            }
        }.start();
    }

    public void insert(Thread thread) {
        lock.lock();
        try {
            System.out.println(thread.getName()+"得到了锁");
            for(int i=0;i<5;i++) {
                arrayList.add(i);
            }
        } catch (Exception e) {
            // TODO: handle exception
        }finally {
            System.out.println(thread.getName()+"释放了锁");
            lock.unlock();
        }
    }
}

【程序结果】

Thread-0得到了锁
Thread-0释放了锁
Thread-1得到了锁
Thread-1释放了锁
ReadWriteLock

ReadWriteLock也是一个接口,在它里面只定义了两个方法:

public interface ReadWriteLock {
    Lock readLock();
    Lock writeLock();
}

一个用来获取读锁,一个用来获取写锁。也就是说将文件的读写操作分开,分成2个锁来分配给线程,从而使得多个线程可以同时进行读操作。

ReentrantReadWriteLock
  • ReentrantReadWriteLock实现了ReadWriteLock接口。
  • ReentrantReadWriteLock里面提供了很多丰富的方法,不过最主要的有两个方法:readLock()和writeLock()用来获取读锁和写锁。
Lock和synchronized的选择
  1. Lock是一个接口,而synchronized是Java中的关键字,synchronized是内置的语言实现;

  2. Lock需要手动释放锁,而用synchronized时,系统会自动让线程释放对锁的占用。
    synchronized在发生异常时,会自动释放线程占有的锁,因此不会导致死锁现象发生;而Lock在发生异常时,如果没有主动通过unLock()去释放锁,则很可能造成死锁现象,因此使用Lock时需要在finally块中释放锁;

  3. Lock可以让等待锁的线程响应中断,而synchronized却不行。
    使用synchronized时,等待的线程会一直等待下去,不能够响应中断;

  4. 通过Lock可以知道有没有成功获取锁,而synchronized却无法办到。

  5. Lock可以提高多个线程进行读操作的效率。
    在性能上来说,如果竞争资源不激烈,两者的性能是差不多的,而当竞争资源非常激烈时(即有大量线程同时竞争),此时Lock的性能要远远优于synchronized。所以说,在具体使用时要根据适当情况选择。

锁的相关概念介绍

可重入锁

synchronized和Lock都是可重入锁

可中断锁

可中断锁:顾名思义,就是可以相应中断的锁。

在Java中,synchronized就不是可中断锁,而Lock是可中断锁。

如果某一线程A正在执行锁中的代码,另一线程B正在等待获取该锁,可能由于等待时间过长,线程B不想等待了,想先处理其他事情,我们可以让它中断自己或者在别的线程中中断它,这种就是可中断锁。

lockInterruptibly()的用法体现了Lock的可中断性。

公平锁和非公平锁

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

在Java中,synchronized就是非公平锁,而对于ReentrantLock和ReentrantReadWriteLock,它默认情况下是非公平锁,但是可以设置为公平锁。

ReentrantLock lock = new ReentrantLock(true);

读写锁

读写锁将对一个资源(比如文件)的访问分成了2个锁,一个读锁和一个写锁。

正因为有了读写锁,才使得多个线程之间的读操作不会发生冲突。

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

可以通过readLock()获取读锁,通过writeLock()获取写锁。

参考资料

java并发 lock锁

相关文章