别忘记奔跑-公平锁/非公平锁/可重入锁/递归锁/自旋锁

最新推荐文章于 2023-10-12 21:53:57 发布

求学旅途

最新推荐文章于 2023-10-12 21:53:57 发布

阅读量135

点赞数 1

分类专栏：自律会带来底气，底气会带来自信，自信会让生活更美好文章标签：多线程 java 并发编程

本文链接：https://blog.csdn.net/youhaitao_do/article/details/112607309

版权

自律会带来底气，底气会带来自信，自信会让生活更美好专栏收录该内容

5 篇文章 0 订阅

订阅专栏

一、我们知道ArrayList是线程不安全，请编写一个不安全的案例并给出解决方案。

二、公平锁/非公平锁/可重入锁/递归锁/自旋锁谈谈你的理解？请手写一个自旋锁

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

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

2.3 自旋锁

2.4 独占锁（写锁）/共享锁（读锁）/互斥锁

一、我们知道ArrayList是线程不安全，请编写一个不安全的案例并给出解决方案。

集合类不安全的问题
* ArrayList

* HashSet(见JUC博客)

* HashMap


import java.util.List;
import java.util.UUID;
import java.util.concurrent.CopyOnWriteArrayList;

/**
 * 集合类不安全的问题
 * ArrayList
 *
 */
public class ContainerNotSafeDemo {
    public static void main(String[] args) {

        List<String> list = new CopyOnWriteArrayList<>();

        for (int i = 0; i < 30; i++) {
            new Thread(() -> {
                list.add(UUID.randomUUID().toString().substring(0, 8));
                System.out.println(list);
            }, String.valueOf(i)).start();
        }
        //java.util.ConcurrentModificationException
        /**
         * 1 故障现象
         *   java.util.ConcurrentModificationException
         * 2 导致原因
         *   并发争抢修改导致，参考我们的花名册签名情况。
         *   一个人正在写入，另外一个同学过来抢夺，导致数据不一致异常。并发修改异常。
         *
         * 3 解决方案
         *   3.1 new Vector<>()
         *   3.2 Collections.synchronizedList(new ArrayList());
         *   3.3 new CopyOnWriteArrayList();
         * 4 优化建议（同样的错误不犯第2次）
         */


/**笔记
 * 写时复制
 CopyOnWrite容器即写时复制的容器。往一个容器添加元素的时候，不直接往当前容器Object[]添加，而是先将当前容器Object[]进行Copy，
 复制出一个新的容器Object[] newElements，然后新的容器Object[] newElements里添加元素，添加完元素之后，
 再将原容器的引用指向新的容器 setArray(newElements);。这样做的好处是可以对CopyOnWrite容器进行并发的读，
 而不需要加锁，因为当前容器不会添加任何元素。所以CopyOnWrite容器也是一种读写分离的思想，读和写不同的容器
 public boolean add(E e)
 {
 final ReentrantLock lock = this.lock;
 lock.lock();
 try
 {
 Object[] elements = getArray();
 int len = elements.length;
 Object[] newElements = Arrays.copyOf(elements, len + 1);
 newElements[len] = e;
 setArray(newElements);
 return true;
 }
 finally {
 lock.unlock();
 }
 }
 */
    }
}

随记随记：栈管运行，堆管存储

二、公平锁/非公平锁/可重入锁/递归锁/自旋锁谈谈你的理解？请手写一个自旋锁

2.1 公平锁和非公平锁

2.1.1 是什么

公平锁 是指多个线程按照申请锁的顺序来获取锁，类似排队打饭，先来后到

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

2.1.2 两者区别

公平锁/非公平锁

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

关于两者区别：

公平锁： Threads acquire a fair lock in the order in which they requested it.

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

非公平锁： a nonfair lock permits barging: threads requesting a lock can jump ahead of the queue of waiting threads if the lock happens to be available when it is requested.

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

2.1.3 题外话

Java ReentrantLock而言，通过构造函数指定该锁是否是公平锁，默认是非公平锁。非公平锁的优点在于吞吐量比公平锁大。

对于Synchronized而言，也是一种非公平锁

2.2 可重入锁（又名递归锁）

2.2.1 是什么

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

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

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

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

2.3 自旋锁

自旋锁（spinlock）

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


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

/**
 * 题目：实现一个自旋锁
 * 自旋锁好处：循环比较获取直到成功为止，没有类似wait的阻塞
 *
 * 通过CAS操作完成自旋锁，A线程先进来调用mylock方法自己持有锁5秒钟，B随后进来后发现
 * 当前有线程持有锁，不是null，所以只能通过自旋等待，直到A释放锁后B随后抢到
 */
public class SpinLockDemo {
    AtomicReference<Thread> atomicReference = new AtomicReference<>();

    public void myLock(){
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName() + "\t come in");
        while (!atomicReference.compareAndSet(null,thread)){

        }
    }

    public void myUnlock(){
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName() + "\t invoked myUnlock");
        atomicReference.compareAndSet(thread,null);
    }

    public static void main(String[] args) {
        SpinLockDemo spinLockDemo = new SpinLockDemo();

        new Thread(()->{
            spinLockDemo.myLock();
            //暂停一会线程
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            spinLockDemo.myUnlock();
        },"AA").start();

        //目的是让AA线程先跑
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            spinLockDemo.myLock();
            //目的是便于看效果
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            spinLockDemo.myUnlock();
        },"BB").start();

    }
}

2.4 独占锁（写锁）/共享锁（读锁）/互斥锁

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

共享锁：指该锁可被多个线程所持有。

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

读锁的共享锁可保证并发读是非常高效的，读写，写读，写写的过程是互斥的。

示例：

1）不加读写锁的情况：

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

class Cache{
    private volatile Map<String,Object> map = new HashMap<>();
    public void put(String key,Object value){
        System.out.println(Thread.currentThread().getName()+"\t 正在写入："+key);
        //暂停一会线程
        try { 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 { TimeUnit.MILLISECONDS.sleep(300); }catch (InterruptedException e){ e.printStackTrace(); }
        Object result = map.get(key);
        System.out.println(Thread.currentThread().getName() + "\t 读取完成："+result);
    }
}

/**
 * 多个线程同时读一个资源类没有任何问题，所以为了满足并发量，读取共享资源应该可以同时进行。
 * 但是
 * 如果有一个线程想去写共享资源来，就不应该再有其它线程可以对该资源进行读或写
 * 小总结：
 *       读-读能共存
 *       读-写不能共存
 *       写-写不能共存
 *
 *       写操作：原子+独占，整个过程必须是一个完整的统一体，中间不许被分割，被打断
 */
public class ReadWriteLockDemo {
    public static void main(String[] args) {
        Cache cache = new Cache();
        for (int i = 0; i < 5; i++) {
            final int finalI = i;
            new Thread(()->{
                cache.put(String.valueOf(finalI),String.valueOf(finalI));
            }, String.valueOf(i)).start();
        }

        for (int i = 0; i < 5; i++) {
            final int tempInt = i;
            new Thread(()->{
                cache.get(tempInt+"");
            }, String.valueOf(i)).start();
        }


    }
}

执行结果：

可以看到，写入不是原子+独占的。写操作的整个过程必须是一个完整的统一体，中间不允许被分割、被打断。

2）加了读写锁

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

class Cache{
    private volatile Map<String,Object> map = new HashMap<>();
    ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    public void put(String key,Object value){
        readWriteLock.writeLock().lock();
        try{
            System.out.println(Thread.currentThread().getName()+"\t 正在写入："+key);
            //暂停一会线程
            try { 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{
            readWriteLock.writeLock().unlock();
        }
    }

    public void get(String key){
        readWriteLock.readLock().lock();
        try{
            System.out.println(Thread.currentThread().getName()+"\t 正在读取：");
            //暂停一会线程
            try { TimeUnit.MILLISECONDS.sleep(300); }catch (InterruptedException e){ e.printStackTrace(); }
            Object result = map.get(key);
            System.out.println(Thread.currentThread().getName() + "\t 读取完成："+result);
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            readWriteLock.readLock().unlock();
        }
    }
}

/**
 * 多个线程同时读一个资源类没有任何问题，所以为了满足并发量，读取共享资源应该可以同时进行。
 * 但是
 * 如果有一个线程想去写共享资源来，就不应该再有其它线程可以对该资源进行读或写
 * 小总结：
 *       读-读能共存
 *       读-写不能共存
 *       写-写不能共存
 *
 *       写操作：原子+独占，整个过程必须是一个完整的统一体，中间不许被分割，被打断
 */
public class ReadWriteLockDemo {
    public static void main(String[] args) {
        Cache cache = new Cache();
        for (int i = 0; i < 5; i++) {
            final int finalI = i;
            new Thread(()->{
                cache.put(String.valueOf(finalI),String.valueOf(finalI));
            }, String.valueOf(i)).start();
        }

        for (int i = 0; i < 5; i++) {
            final int tempInt = i;
            new Thread(()->{
                cache.get(tempInt+"");
            }, String.valueOf(i)).start();
        }


    }
}

执行结果：

求学旅途

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
别忘记奔跑-公平锁/非公平锁/可重入锁/递归锁/自旋锁

一、我们知道ArrayList是线程不安全，请编写一个不安全的案例并给出解决方案。集合类不安全的问题* ArrayList* HashSet(见JUC博客)* HashMapimport java.util.List;import java.util.UUID;import java.util.concurrent.CopyOnWriteArrayList;/** * 集合类不安全的问题 * ArrayList * */public class ContainerN.
复制链接

扫一扫