JAVA多线程-JAVA锁有关内容

于 2022-01-27 21:58:05 发布
阅读量454 收藏
点赞数
分类专栏： JAVA学习 JAVA八股文 文章标签： java 后端 锁 JUC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SIESTA030/article/details/122724256
版权

可重入锁（递归锁）

什么是可重入锁

  • 指的是同一线程的外层函数获得锁之后，内层递归函数仍能获取该锁的代码。
  • 在同一个线程在外层方法获取锁的时候，在进入内层方法会自动获取锁。
  • 线程可以进入一个它已经拥有的锁所同步着的代码块！
  • 也就是说，已经加锁的代码块中还有有锁方法调用，那么这个调用的方法也会获取这个锁。
  • 锁定的是对象，如果获得锁了，那么被这个锁修饰的方法/代码块都可以进行访问。
// method01 是上锁了的，此时内部调用了 method02 方法，
// 此时虽然 method02 也是同步方法，但是调用 method01 之后，他俩共用 method01 的锁。
// 锁里套锁才算是可重入锁。
public synchronized void method01() { 
    method02();
}

public synchronized void method02() {
    
}

作用

  • 最大作用就是用来避免死锁。
  • 避免死锁说的是两个同步方法互相调用的时候，如果不可重入，会造成循环等待，造成死锁。

ReentrantLock类可重入锁

  • 与 synchronized 关键字一样他俩默认都是非公平的可重入锁！
构造方法
public ReentrantLock() {
    sync = new NonfairSync(); // 默认创建一个非公平锁
}

public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync(); // 创建一个公平锁或非公平锁
}
测试案例
package JUC.lock;

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

/**
 * @author zhaolimin
 * @date 2021/11/14
 * @apiNote ReenterLockDemo 测试类
 */

class Test01 {

    Lock lock = new ReentrantLock();

    public void get() {
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t 调用了 get() 方法");
            System.out.println("此时锁为： " + this);
            this.getIn();
        } finally {
            lock.unlock();
        }
    }

    public void getIn() {
        System.out.println(Thread.currentThread().getName() + "\t 调用了getIn() 方法");
        System.out.println("此时锁为： " + this);
    }
}

public class ReenterLockDemo {

    public static void main(String[] args) {
        Test01 test01 = new Test01();
        for (int i = 0; i < 2; i++) {
            new Thread(() -> {
                try {
                    test01.get();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }, String.valueOf(i)).start();
        }

    }
}

/*
    0	 调用了 get() 方法
    此时锁为： JUC.lock.Test01@2322e888
    0	 调用了getIn() 方法
    此时锁为： JUC.lock.Test01@2322e888
    1	 调用了 get() 方法
    此时锁为： JUC.lock.Test01@2322e888
    1	 调用了getIn() 方法
    此时锁为： JUC.lock.Test01@2322e888
*/

Synchronized 关键字可重入锁

测试案例
package JUC.lock;

/**
 * @author zhaolimin
 * @date 2021/11/14
 * @apiNote Synchronized 关键字可重入锁测试
 */

class Tickets {

    public void book() throws Exception{
        synchronized (this) {
            System.out.println(Thread.currentThread().getName() + "\t 调用了 book() 方法");
            System.out.println("此时锁为： " + this);
            this.cancel();
        }
    }

    public void cancel() throws Exception{
        System.out.println(Thread.currentThread().getName() + "\t 调用了 cancel() 方法");
        int index = 0;
        while (true) {
            System.out.println("此时锁为： " + this);
            if (index == 5) {
                break;
            }
            index ++ ;
        }
    }
}
public class SynchronizedDemo {

    public static void main(String[] args) {
        Tickets tickets = new Tickets();
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                try {
                    tickets.book();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }, String.valueOf(i)).start();
        }
    }
}

/*
    0	 调用了 book() 方法
    此时锁为： JUC.lock.Tickets@74c00d
    0	 调用了 cancel() 方法
    此时锁为： JUC.lock.Tickets@74c00d
    此时锁为： JUC.lock.Tickets@74c00d
    此时锁为： JUC.lock.Tickets@74c00d
    此时锁为： JUC.lock.Tickets@74c00d
    此时锁为： JUC.lock.Tickets@74c00d
    此时锁为： JUC.lock.Tickets@74c00d
    1	 调用了 book() 方法
    此时锁为： JUC.lock.Tickets@74c00d
    1	 调用了 cancel() 方法
    此时锁为： JUC.lock.Tickets@74c00d
    此时锁为： JUC.lock.Tickets@74c00d
    此时锁为： JUC.lock.Tickets@74c00d
    此时锁为： JUC.lock.Tickets@74c00d
    此时锁为： JUC.lock.Tickets@74c00d
    此时锁为： JUC.lock.Tickets@74c00d
*/

公平锁和非公平锁

是什么

  • 公平锁：
    • 多个线程按照申请锁的顺序来进行锁的获取，先来后到。
  • 非公平锁：
    • 多个线程获取锁的顺序不按照申请锁的顺序，会出现后申请的线程比先申请的线程先获取锁的情况。
    • 高并发情况下，有可能会造成优先级反转或者饥饿现象。

两者区别

  • 拿ReentrantLock来说。
  • 并发包中的 ReentrantLock 可重入锁可以创建公平锁或非公平锁，默认是非公平锁。
public class LockDemo01 {

    volatile int n = 0;

    public void add() {
        n++;
    }

    public static void main(String[] args) {

        // 非公平锁
        Lock lock1 = new ReentrantLock();

        // 公平锁
        Lock lock2 = new ReentrantLock(true);

    }
}

  • 公平锁在JAVA中来说：

    • 在并发环境中，每个线程在获取锁的时候会先查看此锁维护的等待队列，如果为空，或者当前线程是等待队列的第一个，就占有锁，否则就会加入到等待队列中，按照FIFO的规则从队列中排队等锁。
    • synchronized 也是一种公平锁。

  • 非公平锁在JAVA中来说：

    • 上来线程就可以直接尝试抢占锁，如果成功，直接获取锁，如果不成功，那就按照类似公平锁的方式来获取锁。
    • 优点在于它的吞吐量大。

    ​

自旋锁

是什么

  • 是指尝试获取锁的线程不会立即阻塞，而是采用循环的方式去尝试获取锁。
  • 获取锁的线程一直处于活跃状态，但是并没有执行任何有效的任务，使用这种锁会造成 busy-waiting。
  • 优点是减少线程上下文切换的消耗。
  • 缺点是循环会消耗CPU资源。
  • 可以参考 Unsafe.getAndAddInt 方法。

测试案例

  • 主要采用了 CAS 操作来实现。
package JUC.lock;

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

/**
 * @author zhaolimin
 * @date 2021/11/14
 * @apiNote 自旋锁测试
 */
public class SpinLockDemo {

    // 原子引用线程
    AtomicReference<Thread> threadAtomicReference = new AtomicReference<>();

    public void myLock() {
        Thread thread = Thread.currentThread();
        // 如果期望值是null，主内存中也是null，那主内存中threadAtomicReference的值就为thread
        System.out.println(thread.getName()+ "线程\t 获取锁中。。。");
        while (!threadAtomicReference.compareAndSet(null,thread)) {
            
        }
        System.out.println(thread.getName()+ "线程\t 获取锁成功，占用中。。。");
    }

    public void myUnLock() {
        Thread thread = Thread.currentThread();
        threadAtomicReference.compareAndSet(thread,null);
        System.out.println(thread.getName()+ "线程\t 解锁成功。");
    }

    public static void main(String[] args) {

        SpinLockDemo spinLockDemo = new SpinLockDemo();

        new Thread(() -> {
            spinLockDemo.myLock();
            try {
                TimeUnit.SECONDS.sleep(8);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            spinLockDemo.myUnLock();
        }, "t1").start();

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

        new Thread(() -> {
            spinLockDemo.myLock();
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            spinLockDemo.myUnLock();
        }, "t2").start();

    }
}

/*
  	占用 8 秒 --------------------------
    t1线程	 获取锁中。。。
    t1线程	 获取锁成功，占用中。。。
  
    3 秒后 t2 线程尝试获取锁 --------------------------
    t2线程	 获取锁中。。。
    
    8 秒后 t1 线程释放锁 --------------------------
    t1线程	 解锁成功。
    
    t2线程	 获取锁成功，占用中。。。
    t2线程	 解锁成功。	
*/

读写锁

  • 拆开来，就是独占锁（写锁），共享锁（读锁）。

独占锁

  • 指该锁一次只能被一个线程持有。
  • 对 ReentrantLock类、synchronized 关键字来说都是独占锁。

共享锁

  • 指该锁可可以被多个线程持有。
  • 对 ReentrantReadWriteLocl类来说，读锁为共享锁，写锁为独占锁。
  • 读锁的共享锁可以保证并发环境下线程读的效率。
  • 写写、读写、写读的过程是互斥的。

ReentrantReadWriteLock类

两个重要方法
// 获取写锁，独占锁形式
public ReentrantReadWriteLock.WriteLock writeLock() { 
    return writerLock; 
}
// 获取读锁，共享锁形式
public ReentrantReadWriteLock.ReadLock  readLock()  { 
    return readerLock; 
}

案例

  • 写操作 = 原子 + 独占
  • 读读能共存，读写、写写不能共存。
package JUC.lock;

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

/**
 * @author zhaolimin
 * @date 2021/11/14
 * @apiNote 读写锁测试类。
 */

class MyCache {

    private volatile Map<String,Object> map= new HashMap<>(); // 满足可见性、禁止指令重排
    private ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    public void put(String key, Object value) {

        // 上独占锁写锁。
        readWriteLock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t 正在写入：" + key);
            // 暂停0.3秒。
            try {
                TimeUnit.MICROSECONDS.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            map.put(key, value);
            System.out.println(Thread.currentThread().getName() + "\t 写入完成：" + key);
        } finally {
            readWriteLock.writeLock().unlock();
        }

    }

    public void get(String key) {
        // 上共享读锁
        readWriteLock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t 正在读取：" + key);
            // 暂停0.3秒。
            try {
                TimeUnit.MICROSECONDS.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Object result = map.get(key);
            System.out.println(Thread.currentThread().getName() + "\t 读取完成：" + result );
        } finally {
            readWriteLock.readLock().unlock();
        }
    }

    public void clearMap() {
        map.clear();
    }
}


public class ReadWriteLockDemo {

    public static void main(String[] args) {
        MyCache myCache = new MyCache();

        for (int i = 1; i <= 5; i++) {
            // 匿名内部类使用外部的局部变量，这个局部变量必须用final修饰来保证数据的一致性。
            final int tempInt = i;
            new Thread(() -> {
                myCache.put(tempInt+"", tempInt+"");
            }, String.valueOf(i)).start();
        }

        for (int i = 1; i <= 5; i++) {
            // 匿名内部类使用外部的局部变量，这个局部变量必须用final修饰来保证数据的一致性。
            final int tempInt = i;
            new Thread(() -> {
                myCache.get(tempInt+"");
            }, String.valueOf(i)).start();
        }
    }
}


/*
    2	 正在写入：2
    2	 写入完成：2
    1	 正在写入：1
    1	 写入完成：1
    3	 正在写入：3
    3	 写入完成：3
    4	 正在写入：4
    4	 写入完成：4
    5	 正在写入：5
    5	 写入完成：5
    1	 正在读取：1
    2	 正在读取：2
    3	 正在读取：3
    4	 正在读取：4
    5	 正在读取：5
    1	 读取完成：1
    5	 读取完成：5
    3	 读取完成：3
    2	 读取完成：2
    4	 读取完成：4
*/

码云仓库同步笔记，可自取欢迎各位star指正:https://gitee.com/noblegasesgoo/notes

如果出错希望评论区大佬互相讨论指正，维护社区健康大家一起出一份力，不能有容忍错误知识。
										—————————————————————— 爱你们的 noblegasesgoo
Noblegasesgoo
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值