JUC并发编程之集合的线程安全、多线程锁

01杭呐

已于 2022-12-29 17:00:04 修改

阅读量165

点赞数

分类专栏： JUC并发编程文章标签： jvm 经验分享

于 2022-12-28 14:25:36 首次发布

本文链接：https://blog.csdn.net/weixin_55863682/article/details/128461870

版权

JUC并发编程专栏收录该内容

11 篇文章 0 订阅

订阅专栏

6. 集合的线程安全

6.1 线程不安全演示： java.util.ConcurrentModificationException

6.2 Vector 解决线程不安全问题

6.3 Collections 解决线程不安全问题

6.4 CopyOnWriteArrayList 解决线程不安全问题 (重点)

6. 集合的线程安全

6.1 线程不安全演示： java.util.ConcurrentModificationException

/** 集合线程安全案例
*/
public class NotSafeDemo {
/**
* 多个线程同时对集合进行修改
* @param args
*/
public static void main(String[] args) {
    List list = new ArrayList();
    for (int i = 0; i < 100; i++) {
            new Thread(() ->{
                list.add(UUID.randomUUID().toString());
                System.out.println(list);
                }, "线程" + i).start();    
    }
  }
}

原因：查看 ArrayList 的 add 方法源码

（即源码中ArrayList 的 add方法是没有 synchronized的）
public boolean add(E e) {
    ensureCapacityInternal(size + 1); // Increments modCount!!
    elementData[size++] = e;
    return true;
}

6.2 Vector 解决线程不安全问题

Vector Vector 是矢量队列，它是 JDK1.0 版本添加的类。继承于 AbstractList，实现了 List, RandomAccess, Cloneable 这些接口。 Vector 继承了 AbstractList，实现了 List；所以，它是一个队列，支持相关的添加、删除、修改、遍历等功能。 Vector 实现了 RandmoAccess 接口，即提供了随机访问功能。 RandmoAccess 是 java 中用来被 List 实现，为 List 提供快速访问功能的。在 Vector 中，我们即可以通过元素的序号快速获取元素对象；这就是快速随机访问。 Vector 实现了 Cloneable 接口，即实现 clone()函数。它能被克隆。

==和 ArrayList 不同，Vector 中的操作是线程安全的。==

NotSafeDemo 代码修改

// 只需将6.1的 ArrayList的创建换成Vector即可
//List list = new ArrayList();

List list = new Vector();

没有出现线程异常的原因 -- Vector中的add 方法被 synchronized 同步修辞,线程安全!

因此没有并发异常
public synchronized boolean add(E e) {
    modCount++;
    ensureCapacityHelper(elementCount + 1);
    elementData[elementCount++] = e;
    return true;
}

6.3 Collections 解决线程不安全问题

Collections 提供了方法 synchronizedList 保证 list 是同步线程安全的 NotSafeDemo 代码修改

// 只需将6.1的 ArrayList的创建换成Collections.synchronizedList(new ArrayList<>()) 即可
//List list = new ArrayList();

List list = Collections.synchronizedList(new ArrayList<>())

没有并发修改异常查看方法源码


public static <T> List<T> synchronizedList(List<T> list) {
    return (list instanceof RandomAccess ?
        new SynchronizedRandomAccessList<>(list) :
        new SynchronizedList<>(list));
}

6.4 CopyOnWriteArrayList 解决线程不安全问题 (重点)

首先我们对 CopyOnWriteArrayList 进行学习,其特点如下: 它相当于线程安全的 ArrayList。和 ArrayList 一样，它是个可变数组；但是和 ArrayList 不同的时，它具有以下特性：

1. 它最适合于具有以下特征的应用程序：List 大小通常保持很小，只读操作远多于可变操作，需要在遍历期间防止线程间的冲突。

2. 它是线程安全的。

3. 因为通常需要复制整个基础数组，所以可变操作（add()、set() 和 remove() 等等）的开销很大。

4. 迭代器支持 hasNext(), next()等不可变操作，但不支持可变 remove()等操作。

5. 使用迭代器进行遍历的速度很快，并且不会与其他线程发生冲突。在构造迭代器时，迭代器依赖于不变的数组快照。

1. 独占锁效率低：采用读写分离思想解决

2. 写线程获取到锁，其他写线程阻塞

3. 复制思想：当我们往一个容器添加元素的时候，不直接往当前容器添加，而是先将当前容器进行 Copy，复制出一个新的容器，然后新的容器里添加元素，添加完元素之后，再将原容器的引用指向新的容器。

这时候会抛出来一个新的问题，也就是数据不一致的问题。如果写线程还没来得及写回内存，其他的线程就会读到了脏数据。

==这就是 CopyOnWriteArrayList 的思想和原理。就是拷贝一份。==

NotSafeDemo 代码修改

// 只需将6.1的 ArrayList的创建换成 CopyOnWriteArrayList() 即可
//List list = new ArrayList();

List list = new CopyOnWriteArrayList();

没有线程安全问题

原因分析(重点):==动态数组与线程安全==

下面从“动态数组”和“线程安全”两个方面进一步对 CopyOnWriteArrayList 的原理进行说明。

• “动态数组”机制

o 它内部有个“volatile 数组”(array)来保持数据。在“添加/修改/删除”数据时，都会新建一个数组，并将更新后的数据拷贝到新建的数组中，最后再将该数组赋值给“volatile 数组”, 这就是它叫做 CopyOnWriteArrayList 的原因

o 由于它在“添加/修改/删除”数据时，都会新建数组，所以涉及到修改数据的操作，CopyOnWriteArrayList 效率很低；但是单单只是进行遍历查找的话，效率比较高。

• “线程安全”机制

o 通过 volatile 和互斥锁来实现的。

o 通过“volatile 数组”来保存数据的。一个线程读取 volatile 数组时，总能看到其它线程对该 volatile 变量最后的写入；就这样，通过 volatile 提供了“读取到的数据总是最新的”这个机制的保证。

o 通过互斥锁来保护数据。在“添加/修改/删除”数据时，会先“获取互斥锁”，再修改完毕之后，先将数据更新到“volatile 数组”中，然后再“释放互斥锁”，就达到了保护数据的目的。

6.5 扩展

6.6 小结(重点)

1.线程安全与线程不安全集合

集合类型中存在线程安全与线程不安全的两种,常见例如:

ArrayList ----- Vector

HashMap -----HashTable

但是以上都是通过 synchronized 关键字实现,效率较低

2.Collections 构建的线程安全集合

3.java.util.concurrent 并发包下

CopyOnWriteArrayList CopyOnWriteArraySet 类型,通过动态数组与线程安全个方面保证线程安全

7. 多线程锁

7.1 锁的八个问题演示

class Phone {
     public static synchronized void sendSMS() throws Exception {
         //停留 4 秒
         TimeUnit.SECONDS.sleep(4);
         System.out.println("------sendSMS");
      }

     public synchronized void sendEmail() throws Exception {
         System.out.println("------sendEmail");
     }

     public void getHello() {
     System.out.println("------getHello");
 
}

/** * @Description: 8 锁 *

1 标准访问，先打印短信还是邮件

------sendSMS

------sendEmail

2 停 4 秒在短信方法内，先打印短信还是邮件

------sendSMS

------sendEmail

3 新增普通的 hello 方法，是先打短信还是 hello

------getHello

------sendSMS

4 现在有两部手机，先打印短信还是邮件

------sendEmail

------sendSMS

5 两个静态同步方法，1 部手机，先打印短信还是邮件

------sendSMS

------sendEmail

6 两个静态同步方法，2 部手机，先打印短信还是邮件

------sendSMS

------sendEmail

7 1 个静态同步方法,1 个普通同步方法，1 部手机，先打印短信还是邮件

------sendEmail

------sendSMS

8 1 个静态同步方法,1 个普通同步方法，2 部手机，先打印短信还是邮件

------sendEmail

------sendSMS

7.2 结论

1 看锁的作用范围

2 看锁的作用对象

一个对象里面如果有多个 synchronized 方法，某一个时刻内，只要一个线程去调用其中的一个 synchronized 方法了，

其它的线程都只能等待，换句话说，某一个时刻内，只能有唯一一个线程去访问这些 synchronized 方法锁的是当前对象 this，被锁定后，其它的线程都不能进入到当前对象的其它的 synchronized 方法

加个普通方法后发现和同步锁无关换成两个对象后，不是同一把锁了，情况立刻变化。 synchronized 实现同步的基础：Java 中的每一个对象都可以作为锁。

具体表现为以下 3 种形式。

对于普通同步方法，锁是当前实例对象。

对于静态同步方法，锁是当前类的 Class 对象。

对于同步方法块，锁是 Synchonized 括号里配置的对象

当一个线程试图访问同步代码块时，它首先必须得到锁，退出或抛出异常时必须释放锁。 也就是说如果一个实例对象的非静态同步方法获取锁后，该实例对象的其他非静态同步方法必须等待获取锁的方法释放锁后才能获取锁，可是别的实例对象的非静态同步方法因为跟该实例对象的非静态同步方法用的是不同的锁，所以毋须等待该实例对象已获取锁的非静态同步方法释放锁就可以获取他们自己的锁。所有的静态同步方法用的也是同一把锁——类对象本身，这两把锁是两个不同的对象，所以静态同步方法与非静态同步方法之间是不会有竞态条件的。但是一旦一个静态同步方法获取锁后，其他的静态同步方法都必须等待该方法释放锁后才能获取锁，而不管是同一个实例对象的静态同步方法之间，还是不同的实例对象的静态同步方法之间，只要它们同一个类的实例对象！

7.3 公平锁和非公平锁

公平锁：效率低，但cpu利用率高
非公平锁：抢占式、效率高，但线程容易饿死

用法： 在创建可重入锁时，想构造器中传入true

private final ReentrantLock lock = new ReentrantLock(true);

ReentrantLock 的构造器源码如下：

// 在没有传入参数时，默认创建一个非公平锁
public ReentrantLock() {
    sync = new NonfairSync();
}
// 当传入一个true值时，为公平锁
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

7.4 可重入锁

synchronized和lock都是可重入锁

sychronized：隐式锁，自动上锁与解锁，而lock为显示锁，需要手动上锁与解锁
可重入锁也叫递归锁（synchronized是jvm帮我们做加锁解锁）
重复获取锁有一个加锁计数器，同一个对象获取同一个锁时+1，离开时-1，到0就完全释放锁

ReentrantLock的示例代码

/**
 * lock和unlock的数量必须一致，否则会出现死锁
 * */
public class WhatReentrantLock {
    public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock();
        new Thread(()->{
            // 上锁
            lock.lock();
            try {
                System.out.println("这是第一层锁");
                // 再次上锁
                lock.lock();
                try{
                    System.out.println("这是第二层锁");
                }finally {
                    lock.unlock();
                }
            }finally {
                lock.unlock();
            }
        }).start();
    }
}

7.5 死锁

死锁产生的情景：两个或以上的进程因为争夺资源而造成互相等待资源的现象称为死锁

死锁产生的原因：

系统资源不足
系统资源分配不当
进程运行顺序不当

死锁产生四大必要条件：互斥，请求保持，不可剥夺，循环等待

死锁图解

7.6 如何判断死锁

jps -l (类似 Linux中的 ps -ef 查看进程号)
jstack （JVM自带的堆栈的跟踪g工具）

使用：jstack + 进程号查看

死锁的操作代码实列

public class DeadLock {
 
    //创建两个对象
    static Object a = new Object();
    static Object b = new Object();
 
    public static void main(String[] args) {
        new Thread(()->{
            // 获取a这把锁
            synchronized (a) {
                System.out.println(Thread.currentThread().getName()+" 持有锁a，试图获取锁b");
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (b) {
                    System.out.println(Thread.currentThread().getName()+" 获取锁b");
                }
            }
        },"A").start();
 
        new Thread(()->{
            // 获取b这把锁
            synchronized (b) {
                System.out.println(Thread.currentThread().getName()+" 持有锁b，试图获取锁a");
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (a) {
                    System.out.println(Thread.currentThread().getName()+" 获取锁a");
                }
            }
        },"B").start();
    }
}