JUC面试（六）——Java锁

阿里云国内75折 回扣 微信号：monov8
阿里云国际，腾讯云国际，低至75折。AWS 93折 免费开户实名账号 代冲值 优惠多多 微信号：monov8 飞机：@monov6

Java锁

公平锁和非公平锁

概念

公平锁

是指多个线程按照申请锁的顺序来获取锁类似于排队买饭先来后到先来先服务就是公平的也就是队列

非公平锁

是指多个线程获取锁的顺序并不是按照申请锁的顺序有可能申请的线程比先申请的线程优先获取锁在高并发环境下有可能造成优先级翻转或者饥饿的线程也就是某个线程一直得不到锁

如何创建

并发包中ReentrantLock的创建可以指定析构函数的boolean类型来得到公平锁或者非公平锁默认是非公平锁

/**
* 创建一个可重入锁true 表示公平锁false 表示非公平锁。无参默认非公平锁
*/
Lock lock = new ReentrantLock(true);

两者区别

公平锁就是很公平在并发环境中每个线程在获取锁时会先查看此锁维护的等待队列如果为空或者当前线程是等待队列中的第一个就占用锁否者就会加入到等待队列中以后安装FIFO的规则从队列中取到自己

非公平锁 非公平锁比较粗鲁上来就直接尝试占有锁如果尝试失败就再采用类似公平锁那种方式。

题外话

Java ReenttrantLock通过构造函数指定该锁是否公平默认是非公平锁因为非公平锁的优点在于吞吐量比公平锁大对于synchronized而言也是一种非公平锁

可重入锁递归锁

ReentrantLock

概念

可重入锁就是递归锁

指的是同一线程外层函数获得锁之后内层递归函数仍然能获取到该锁的代码在同一线程在外层方法获取锁的时候在进入内层方法会自动获取锁

也就是说线程可以进入任何一个它已经拥有的锁所同步的代码块

ReentrantLock / Synchronized 就是一个典型的可重入锁

代码

可重入锁就是在一个method1方法中加入一把锁方法2也加锁了method1调用method2那么他们拥有的是同一把锁

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

public synchronized void method2() {

}

也就是说我们只需要进入method1后那么它也能直接进入method2方法因为他们所拥有的锁是同一把。method1可以拿到method2所有的代码块。

作用

可重入锁的最大作用就是避免死锁

可重入锁验证

证明Synchronized

/**
 * 可重入锁也叫递归锁
 * 指的是同一线程外层函数获得锁之后内层递归函数仍然能获取到该锁的代码在同一线程在外层方法获取锁的时候在进入内层方法会自动获取锁
 *
 * 也就是说`线程可以进入任何一个它已经拥有的锁所同步的代码块`
 * @author: wzq
 * @create: 2020-03-15-12:12
 */

/**
 * 资源类
 */
class Phone {

    /**
     * 发送短信
     * @throws Exception
     */
    public synchronized void sendSMS() throws Exception{
        System.out.println(Thread.currentThread().getName() + "\t invoked sendSMS()");

        // 在同步方法中调用另外一个同步方法
        // 锁住同步的代码块同一把锁
        sendEmail();
    }

    /**
     * 发邮件
     * @throws Exception
     */
    public synchronized void sendEmail() throws Exception{
        System.out.println(Thread.currentThread().getName() + "\t invoked sendEmail()");
    }
}
public class ReenterLockDemo {


    public static void main(String[] args) {
        Phone phone = new Phone();

        // 两个线程操作资源列
        new Thread(() -> {
            try {
                phone.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "t1").start();

        new Thread(() -> {
            try {
                phone.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "t2").start();
    }
}

在这里我们编写了一个资源类phone拥有两个加了synchronized的同步方法分别是sendSMS 和 sendEmail我们在sendSMS方法中调用sendEmail。最后在主线程同时开启了两个线程进行测试最后得到的结果为

在这里插入图片描述

这就说明当 t1 线程进入sendSMS的时候拥有了一把锁同时t2线程无法进入直到t1线程拿着锁执行了sendEmail 方法后才释放锁这样t2才能够进入

t1	 invoked sendSMS()      t1线程在外层方法获取锁的时候
t1	 invoked sendEmail()    t1在进入内层方法会自动获取锁

t2	 invoked sendSMS()      t2线程在外层方法获取锁的时候
t2	 invoked sendEmail()    t2在进入内层方法会自动获取锁

method2不加synchronized结果也一样。

父子类继承关系

关键字synchronized不能被继承

1、子类继承父类时如果没有重写父类中的同步方法子类同一对象在不同线程并发调用该方法时具有同步效果。

2、子类继承父类并且重写父类中的同步方法但没有添加关键字synchronized子类同一对象在不同线程并发调用该方法时不再具有同步效果。

当存在父子类继承关系时子类是完全可以通过“可重入锁”调用父类的同步方法的

验证如下

public class Widget {
    public synchronized void doSomething() {
        System.out.println("Widget中的this: " + this);
    }
}
 
public class LoggingWidget extends Widget {
    @Override
    public synchronized void doSomething() {
        super.doSomething();
        System.out.println("LoggingWidget中的super: " + super.toString());
        System.out.println("LoggingWidget中的this: " + this);
    }
 
    public static void main(String[] args) {
        LoggingWidget loggingWidget = new LoggingWidget();
        loggingWidget.doSomething();
    }
}

结果

Widget中的this: com.wzq.basics.lock.LoggingWidget@1540e19d
LoggingWidget中的super: com.wzq.basics.lock.LoggingWidget@1540e19d
LoggingWidget中的this: com.wzq.basics.lock.LoggingWidget@1540e19d

不仅子类可重入父类同步方法而且子类的super和this是同一引用都是子类对象锁住的是子类对象。也就是super本身仍然是子类的引用只不过它可以调用到父类的方法或变量。

证明ReentrantLock

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 资源类
 */
class Phone implements Runnable{

    Lock lock = new ReentrantLock();

    /**
     * set进去的时候就加锁调用set方法的时候能否访问另外一个加锁的set方法
     */
    public void getLock() {
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t get Lock");
            setLock();
        } finally {
            lock.unlock();
        }
    }

    public void setLock() {
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t set Lock");
        } finally {
            lock.unlock();
        }
    }

    @Override
    public void run() {
        getLock();
    }
}
public class ReenterLockDemo {


    public static void main(String[] args) {
        Phone phone = new Phone();

        /**
         * 因为Phone实现了Runnable接口
         */
        Thread t3 = new Thread(phone, "t3");
        Thread t4 = new Thread(phone, "t4");
        t3.start();
        t4.start();
    }
}

现在我们使用ReentrantLock进行验证首先资源类实现了Runnable接口重写Run方法里面调用get方法get方法在进入的时候就加了锁

然后在方法里面又调用另外一个加了锁的setLock方法

最后输出结果我们能发现结果和加synchronized方法是一致的都是在外层的方法获取锁之后线程能够直接进入里层一旦get方法进去后其它线程无法访问set方法。

在这里插入图片描述

当我们在getLock方法加两把锁会是什么情况呢 (阿里面试)

    public void getLock() {
        lock.lock();
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t get Lock");
            setLock();
        } finally {
            lock.unlock();
            lock.unlock();
        }
    }

最后得到的结果也是一样的因为里面不管有几把锁其它他们都是同一把锁也就是说用同一个钥匙都能够打开

当我们在getLock方法加两把锁但是只解一把锁会出现什么情况呢

public void getLock() {
    lock.lock();
    lock.lock();
    try {
        System.out.println(Thread.currentThread().getName() + "\t get Lock");
        setLock();
    } finally {
        lock.unlock();
    }
}

得到结果

t3	 get Lock
t3	 set Lock

也就是说程序直接卡死线程不能出来也就说明我们申请几把锁最后需要解除几把锁不然死锁了其它线程也访问不了。

当我们只加一把锁但是用两把锁来解锁的时候又会出现什么情况呢

    public void getLock() {
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t get Lock");
            setLock();
        } finally {
            lock.unlock();
            lock.unlock();
        }
    }

这个时候运行程序会直接报错

t3	 get Lock
t3	 set Lock
t4	 get Lock
t4	 set Lock
Exception in thread "t3" Exception in thread "t4" 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 com.moxi.interview.study.thread.Phone.getLock(ReenterLockDemo.java:52)
	at com.moxi.interview.study.thread.Phone.run(ReenterLockDemo.java:67)
	at java.lang.Thread.run(Thread.java:745)
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 com.moxi.interview.study.thread.Phone.getLock(ReenterLockDemo.java:52)
	at com.moxi.interview.study.thread.Phone.run(ReenterLockDemo.java:67)
	at java.lang.Thread.run(Thread.java:745)

自旋锁

自旋锁spinlock是指尝试获取锁的线程不会立即阻塞而是采用循环的方式去尝试获取锁这样的好处是减少线程上下文切换的消耗缺点是循环会消耗CPU

原来提到的比较并交换底层使用的就是自旋自旋就是多次尝试多次访问不会阻塞的状态就是自旋。

在这里插入图片描述

优缺点

优点循环比较获取直到成功为止没有类似于wait的阻塞

缺点当不断自旋的线程越来越多的时候会因为执行while循环不断的消耗CPU资源

手写自旋锁

通过CAS操作完成自旋锁A线程先进来调用myLock方法自己持有锁5秒B随后进来发现当前有线程持有锁不是null所以只能通过自旋等待直到A释放锁后B随后抢到

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;

/**
 * 手写一个自旋锁
 *
 * 循环比较获取直到成功为止没有类似于wait的阻塞
 *
 * 通过CAS操作完成自旋锁A线程先进来调用myLock方法自己持有锁5秒B随后进来发现当前有线程持有锁不是null所以只能通过自旋等待直到A释放锁后B随后抢到
 * @author: wzq
 * @create: 2020-03-15-15:46
 */
public class SpinLockDemo {

    // 现在的泛型装的是Thread原子引用线程
    AtomicReference<Thread> atomicReference = new AtomicReference<>();

    public void myLock() {
        // 获取当前进来的线程
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName() + "\t come in ");

        // 开始自旋期望值是null更新值是当前线程如果是null则更新为当前线程否者自旋
        while(!atomicReference.compareAndSet(null, thread)) {

        }
    }

    /**
     * 解锁
     */
    public void myUnLock() {

        // 获取当前进来的线程
        Thread thread = Thread.currentThread();

        // 自己用完了后把atomicReference变成null
        atomicReference.compareAndSet(thread, null);

        System.out.println(Thread.currentThread().getName() + "\t invoked myUnlock()");
    }

    public static void main(String[] args) {

        SpinLockDemo spinLockDemo = new SpinLockDemo();

        // 启动t1线程开始操作
        new Thread(() -> {

            // 开始占有锁
            spinLockDemo.myLock();


            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            // 开始释放锁
            spinLockDemo.myUnLock();

        }, "t1").start();


        // 让main线程暂停1秒使得t1线程先执行
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 1秒后启动t2线程开始占用这个锁
        new Thread(() -> {

            // 开始占有锁
            spinLockDemo.myLock();
            // 开始释放锁
            spinLockDemo.myUnLock();

        }, "t2").start();

    }
}

在这里插入图片描述

最后输出结果

t1	 come in 
.....一秒后.....
t2	 come in 
.....五秒后.....
t1	 invoked myUnlock()
t2	 invoked myUnlock()

首先输出的是 t1 come in

然后1秒后t2线程启动发现锁被t1占有所有不断的执行 compareAndSet方法来进行比较直到t1释放锁后也就是5秒后t2成功获取到锁然后释放

独占锁写锁& 共享锁读锁&互斥锁

概念

独占锁指该锁一次只能被一个线程所持有。对ReentrantLock和Synchronized而言都是独占锁

共享锁指该锁可以被多个线程锁持有

对ReentrantReadWriteLock其读锁是共享其写锁是独占

写的时候只能一个人写但是读的时候可以多个人同时读

为什么会有写锁和读锁

原来我们使用ReentrantLock创建锁的时候是独占锁也就是说一次只能一个线程访问但是有一个读写分离场景读的时候想同时进行因此原来独占锁的并发性就没这么好了因为读锁并不会造成数据不一致的问题因此可以多个人共享读

多个线程 同时读一个资源类没有任何问题所以为了满足并发量读取共享资源应该可以同时进行但是如果一个线程想去写共享资源就不应该再有其它线程可以对该资源进行读或写

读-读能共存

读-写不能共存

写-写不能共存

代码实现

实现一个读写缓存的操作假设开始没有加锁的时候会出现什么情况

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;


/**
 * 读写锁
 * 多个线程 同时读一个资源类没有任何问题所以为了满足并发量读取共享资源应该可以同时进行
 * 但是如果一个线程想去写共享资源就不应该再有其它线程可以对该资源进行读或写
 *
 * @author: wzq
 * @create: 2020-03-15-16:59
 */


/**
 * 资源类
 */
class MyCache {

    private volatile Map<String, Object> map = new HashMap<>();
    // private Lock lock = null;

    /**
     * 定义写操作
     * 满足原子 + 独占
     * @param key
     * @param value
     */
    public void put(String key, Object value) {
        System.out.println(Thread.currentThread().getName() + "\t 正在写入" + key);
        try {
            // 模拟网络拥堵延迟0.3秒
            TimeUnit.MILLISECONDS.sleep(300);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        map.put(key, value);
        System.out.println(Thread.currentThread().getName() + "\t 写入完成");
    }

    public void get(String key) {
        System.out.println(Thread.currentThread().getName() + "\t 正在读取:");
        try {
            // 模拟网络拥堵延迟0.3秒
            TimeUnit.MILLISECONDS.sleep(300);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Object value = map.get(key);
        System.out.println(Thread.currentThread().getName() + "\t 读取完成" + value);
    }

}

public class ReadWriteLockDemo {

    public static void main(String[] args) {

        MyCache myCache = new MyCache();
        // 线程操作资源类5个线程写
        for (int i = 0; i < 5; i++) {
            // lambda表达式内部必须是final
            final int tempInt = i;
            new Thread(() -> {
                myCache.put(tempInt + "", tempInt +  "");
            }, String.valueOf(i)).start();
        }
        // 线程操作资源类 5个线程读
        for (int i = 0; i < 5; i++) {
            // lambda表达式内部必须是final
            final int tempInt = i;
            new Thread(() -> {
                myCache.get(tempInt + "");
            }, String.valueOf(i)).start();
        }
    }
}

最后运行结果

0	 正在写入0
4	 正在写入4
3	 正在写入3
1	 正在写入1
2	 正在写入2
0	 正在读取:
1	 正在读取:
2	 正在读取:
3	 正在读取:
4	 正在读取:
2	 写入完成
4	 写入完成
4	 读取完成null
0	 写入完成
3	 读取完成null
0	 读取完成null
1	 写入完成
3	 写入完成
1	 读取完成null
2	 读取完成null

我们可以看到在写入的时候写操作都被其它线程打断了这就造成了还没写完其它线程又开始写这样就造成数据不一致。

解决方法

ReadWriteLock读写锁接口实现类ReentrantReadWriteLock。

上面的代码是没有加锁的这样就会造成线程在进行写入操作的时候被其它线程频繁打断从而不具备原子性这个时候我们就需要用到读写锁来解决了

/**
* 创建一个读写锁
* 它是一个读写融为一体的锁在使用的时候需要转换
*/
private ReadWriteLock rwLock = new ReentrantReadWriteLock();

当我们在进行写操作的时候就需要转换成写锁

// 创建一个写锁
rwLock.writeLock().lock();

// 写锁 释放
rwLock.writeLock().unlock();

当们在进行读操作的时候在转换成读锁

// 创建一个读锁
rwLock.readLock().lock();

// 读锁 释放
rwLock.readLock().unlock();

这里的读锁和写锁的区别在于写锁一次只能一个线程进入执行写操作而读锁是多个线程能够同时进入进行读取的操作

完整代码

/**
 * 读写锁
 * 多个线程 同时读一个资源类没有任何问题所以为了满足并发量读取共享资源应该可以同时进行
 * 但是如果一个线程想去写共享资源就不应该再有其它线程可以对该资源进行读或写
 *
 * @author: wzq
 * @create: 2020-03-15-16:59
 */

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * 资源类
 */
class MyCache {

    /**
     * 缓存中的东西必须保持可见性因此使用volatile修饰
     */
    private volatile Map<String, Object> map = new HashMap<>();

    /**
     * 创建一个读写锁
     * 它是一个读写融为一体的锁在使用的时候需要转换
     */
    private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();

    /**
     * 定义写操作
     * 满足原子 + 独占
     * @param key
     * @param value
     */
    public void put(String key, Object value) {

        // 创建一个写锁
        rwLock.writeLock().lock();

        try {

            System.out.println(Thread.currentThread().getName() + "\t 正在写入" + key);

            try {
                // 模拟网络拥堵延迟0.3秒
                TimeUnit.MILLISECONDS.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            map.put(key, value);

            System.out.println(Thread.currentThread().getName() + "\t 写入完成");

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 写锁 释放
            rwLock.writeLock().unlock();
        }
    }

    /**
     * 获取
     * @param key
     */
    public void get(String key) {

        // 读锁
        rwLock.readLock().lock();
        try {

            System.out.println(Thread.currentThread().getName() + "\t 正在读取:");

            try {
                // 模拟网络拥堵延迟0.3秒
                TimeUnit.MILLISECONDS.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            Object value = map.get(key);

            System.out.println(Thread.currentThread().getName() + "\t 读取完成" + value);

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 读锁释放
            rwLock.readLock().unlock();
        }
    }

    /**
     * 清空缓存
     */
    public void clean() {
        map.clear();
    }


}
public class ReadWriteLockDemo {

    public static void main(String[] args) {

        MyCache myCache = new MyCache();

        // 线程操作资源类5个线程写
        for (int i = 1; i <= 5; i++) {
            // lambda表达式内部必须是final
            final int tempInt = i;
            new Thread(() -> {
                myCache.put(tempInt + "", tempInt +  "");
            }, String.valueOf(i)).start();
        }

        // 线程操作资源类 5个线程读
        for (int i = 1; i <= 5; i++) {
            // lambda表达式内部必须是final
            final int tempInt = i;
            new Thread(() -> {
                myCache.get(tempInt + "");
            }, String.valueOf(i)).start();
        }
    }
}

运行结果

1	 正在写入1
1	 写入完成
2	 正在写入2
2	 写入完成
3	 正在写入3
3	 写入完成
4	 正在写入4
4	 写入完成
5	 正在写入5
5	 写入完成
2	 正在读取:
3	 正在读取:
1	 正在读取:
4	 正在读取:
5	 正在读取:
2	 读取完成2
1	 读取完成1
4	 读取完成4
3	 读取完成3
5	 读取完成5

从运行结果我们可以看出写入操作是一个一个线程进行执行的并且中间不会被打断而读操作的时候是同时5个线程进入然后并发读取操作

乐观锁&悲观锁

悲观锁指一直认为其他线程会过来抢占资源采取加锁互斥的方式。Java 中的 Synchronized 和 ReentrantLock 等独占锁(排他锁)也是一种悲观锁思想的实现。

乐观锁指认为在修改数据前不会有其它线程过来修改数据乐观锁的实现方案一般来说有两种 版本号机制 和 CAS实现 。juc中的AtomicStampedReference时间戳原子引用就是乐观锁实现。

阿里云国内75折 回扣 微信号：monov8
阿里云国际，腾讯云国际，低至75折。AWS 93折 免费开户实名账号 代冲值 优惠多多 微信号：monov8 飞机：@monov6
标签: Java
返回列表

上一篇：2023年春节祝福第二弹——送你一只守护兔(下），CSS3 动画相关属性图例实例大全（82种），守护兔源代码免费下载

下一篇：基于BP神经网络预测日本麻将立直听牌

“JUC面试（六）——Java锁” 的相关文章

ZoomCharts JavaScript 1.20.2 Crack1年前 (2023-02-02)
内含JAVA简单概括和JAVA所需安装的软件和详细教程,想学习JAVA无从下手,这篇文章带你迈出第一步1年前 (2023-02-02)
Java GUI——Java图形用户界面_java图形界面1年前 (2023-02-02)
java文件转二进制1年前 (2023-02-02)
基于Java+SpringBoot+vue+elementui药品商城采购系统详细设计实现1年前 (2023-02-02)
at java.net.URLClassLoader.findClass(URLClassLoader.java:382)1年前 (2023-02-02)
新的一年到了，小超祝大家在新的一年开开心心，财源滚滚哈，也希望新的一年多多支持这个平台哈哈，我也会在悠闲的时间写一篇博客，作为新年礼物，用HTML加CSS加JAVAScrpit做了一份新年祝福语录哈，1年前 (2023-02-02)
### Cause: java.sql.SQLSyntaxErrorException: ORA-00911: 无效字符1年前 (2023-02-02)
【JavaEE】进入Web开发的世界-CSS1年前 (2023-02-02)
Solon Java Framework v1.12.2 发布1年前 (2023-02-02)

阿里云国际版