LOCK和synchronized的区别

最新推荐文章于 2021-06-21 13:38:41 发布

Asher1

最新推荐文章于 2021-06-21 13:38:41 发布

阅读量144

点赞数

分类专栏：【JAVASE】

本文链接：https://blog.csdn.net/a447332241/article/details/107958715

版权

【JAVASE】专栏收录该内容

10 篇文章 0 订阅

订阅专栏

1.synchronized的缺点

1）当一个代码块被synchronized修饰的时候，一个线程获取到了锁，并且执行代码块，那么其他的线程需要等待正在使用的线程释放掉这个锁，那么释放锁的方法只有两种，一种是代码执行完毕自动释放，一种是发生异常以后jvm会让线程去释放锁。那么如果这个正在执行的线程遇到什么问题，比如等待IO或者调用sleep方法等等被阻塞了，无法释放锁，而这时候其他线程只能一直等待，将会特别影响效率。那么有没有一种办法让其他线程不必一直傻乎乎的等在这里吗？

2）当一个文件，同时被多个线程操作时，读操作和写操作会发生冲突，写操作和写操作会发生冲突，而读操作和读操作并不会冲突，但是如果我们用synchronized的话，会导致一个线程在读的时候，其他线程想要读的话只能等待，那么有什么办法能不锁读操作吗？

3）在使用synchronized时，我们无法得知线程是否成功获取到锁，那么有什么办法能知道是否获取到锁吗？

2.LOCK

1)Lock是一个接口，源码如下

public interface Lock {
    void lock();
    void lockInterruptibly() throws InterruptedException;
    boolean tryLock();
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
    void unlock();
    Condition newCondition();
}

ReentrantLock是Lock的一个实现类（另外两个实现类是ReentrantReadWriteLock类下的两个静态内部类：WriteLock和ReadLock），它的意思是可重入锁，可重入锁前面已经讲过了。ReentrantLock中提供了更多的一些方法。不过常用的就是Lock中的这些。

来看一下Lock接口这些方法的使用，lock()、tryLock()、tryLock(long time, TimeUnit unit)和lockInterruptibly()是用来获取锁的。unLock()方法是用来释放锁的。

这里有四个方法来获取锁，那么区别在哪里呢？

lock()使我们平时用的最多的，最用是用来获取锁，如果锁已经被其他线程获取，那么就等待。但是采用Lock必须要主动释放锁，所以我们一般在try{}catch{}块中处理然后在finally中释放锁，举个例子：

lock.lock();
try{
    // 处理
}catch(Exception ex){
    // 捕获异常
}finally{
    // 释放锁
    lock.unlock();
}

tryLock()是一个boolean类型的方法，当调用这个方法的时候，线程会去尝试获取锁，如果获取到的话会返回true，如果获取不到返回false，也就是说这个方法会立马返回一个结果，线程不会等待。

tryLock(long time, TimeUnit unit)是上面tryLock()方法的一个重载方法，加了两个参数，给定了等待的时间，如果在规定时间拿到锁返回true，如果拿不到返回false。这两个方法的一般用法和Lock类似。

2）ReadWriteLock

ReadWriteLock也是一个接口，这个接口中只有两个方法，源码如下：

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

这个接口的从字面就能看出来他的用途，读锁和写锁，这时候是不是想起了前面我写到的synchronized的第二条。

ReentrantReadWriteLock是ReadWriteLock的一个实现类，最常用到的也是获取读锁和获取写锁。下面看例子：

首先是使用synchronized的：

public class Main {
    public static void main(String[] args)  {
        final Main m = new Main();

        new Thread(){
            public void run() {
                m.read(Thread.currentThread());
            };
        }.start();

        new Thread(){
            public void run() {
                m.read(Thread.currentThread());
            };
        }.start();
    }

    public synchronized void read(Thread thread) {
        long startTime = System.currentTimeMillis();
        while(System.currentTimeMillis() - startTime <= 1) {
            System.out.println(thread.getName()+"线程在进行读操作");
        }
        System.out.println(thread.getName()+"线程完成读操作");
    }
}

这段代码的执行结果是在一个线程打印出完成读操作后，另一条线程才会开始进行读操作。

Thread-0线程在进行读操作
Thread-0线程在进行读操作
Thread-0线程在进行读操作
Thread-0线程在进行读操作
Thread-0线程在进行读操作
Thread-0线程在进行读操作
Thread-0线程在进行读操作
Thread-0线程在进行读操作
Thread-0线程在进行读操作
Thread-0线程在进行读操作
Thread-0线程在进行读操作
Thread-0线程在进行读操作
Thread-0线程在进行读操作
Thread-0线程在进行读操作
Thread-0线程在进行读操作
Thread-0线程在进行读操作
Thread-0线程在进行读操作
Thread-0线程在进行读操作
Thread-0线程在进行读操作
Thread-0线程在进行读操作
Thread-0线程在进行读操作
Thread-0线程在进行读操作
Thread-0线程在进行读操作
Thread-0线程在进行读操作
Thread-0线程在进行读操作
Thread-0线程在进行读操作
Thread-0线程完成读操作
Thread-1线程在进行读操作
Thread-1线程在进行读操作
Thread-1线程在进行读操作
Thread-1线程在进行读操作
Thread-1线程在进行读操作
Thread-1线程在进行读操作
Thread-1线程在进行读操作
Thread-1线程在进行读操作
Thread-1线程在进行读操作
Thread-1线程在进行读操作
Thread-1线程在进行读操作
Thread-1线程在进行读操作
Thread-1线程在进行读操作
Thread-1线程在进行读操作
Thread-1线程在进行读操作
Thread-1线程在进行读操作
Thread-1线程在进行读操作
Thread-1线程在进行读操作
Thread-1线程在进行读操作
Thread-1线程在进行读操作
Thread-1线程在进行读操作
Thread-1线程在进行读操作
Thread-1线程在进行读操作
Thread-1线程在进行读操作
Thread-1线程在进行读操作
Thread-1线程完成读操作

下面看如果用ReadWriteLock：

public class Main {
    public static void main(String[] args)  {
        private ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
        final Main m = new Main();

        new Thread(){
            public void run() {
                m.read(Thread.currentThread());
            };
        }.start();

        new Thread(){
            public void run() {
                m.read(Thread.currentThread());
            };
        }.start();
    }

    public void read(Thread thread) {
        readWriteLock.readLock().lock();
        try {
        long startTime = System.currentTimeMillis();
            while(System.currentTimeMillis() - startTime <= 1) {
                System.out.println(thread.getName()+"线程在进行读操作");
            }
            System.out.println(thread.getName()+"线程完成读操作");
    } finally {
        readWriteLock.unlock();
        }
    }
}

只是把之前的synchronized换成了ReadWriteLock，但是输出结果却是两个线程在一起进行读操作

Thread-0线程在进行读操作
Thread-0线程在进行读操作
Thread-1线程在进行读操作
Thread-0线程在进行读操作
Thread-1线程在进行读操作
Thread-0线程在进行读操作
Thread-1线程在进行读操作
Thread-1线程在进行读操作
Thread-1线程在进行读操作
Thread-1线程在进行读操作
Thread-1线程在进行读操作
Thread-0线程在进行读操作
Thread-0线程在进行读操作
Thread-0线程在进行读操作
Thread-1线程在进行读操作
Thread-1线程在进行读操作
Thread-1线程在进行读操作
Thread-1线程在进行读操作
Thread-1线程在进行读操作
Thread-1线程在进行读操作
Thread-1线程在进行读操作
Thread-0线程在进行读操作
Thread-0线程在进行读操作
Thread-1线程在进行读操作
Thread-1线程在进行读操作
Thread-0线程在进行读操作
Thread-1线程在进行读操作
Thread-1线程在进行读操作
Thread-0线程在进行读操作
Thread-1线程在进行读操作
Thread-1线程在进行读操作
Thread-1线程在进行读操作
Thread-0线程在进行读操作
Thread-1线程在进行读操作
Thread-1线程在进行读操作
Thread-0线程在进行读操作
Thread-1线程在进行读操作
Thread-0线程在进行读操作
Thread-1线程在进行读操作
Thread-0线程在进行读操作
Thread-1线程在进行读操作
Thread-0线程在进行读操作
Thread-1线程在进行读操作
Thread-0线程在进行读操作
Thread-1线程在进行读操作
Thread-0线程在进行读操作
Thread-1线程在进行读操作
Thread-0线程在进行读操作
Thread-1线程在进行读操作
Thread-0线程完成读操作
Thread-1线程完成读操作

这个结果可以看到两个线程同时进行读操作，效率大大的提升了。但是要注意的是，如果一个线程获取了读锁，那么另外的线程想要获取写锁则需要等待释放；而如果一个线程已经获取了写锁，则另外的线程想获取读锁或写锁都需要等待写锁被释放。