文章目录

集合操作 Demo
Vector
Collections
CopyOnWriteArrayList(重点)
HashSet 例子
HashMap例子
小结(重点)

集合操作 Demo

package com.thr_safety;

import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

public class ThreadDemo3 {

    public static void main(String[] args) {

        //建立一个ArrayList 集合
        List<String> list = new ArrayList<>();

        for (int i = 0; i < 30; i++) {
            //在循环中添加线程
            new Thread( () -> {
                //在线程中将随机数添加到集合中(ArrayList)
                list.add( UUID.randomUUID().toString().substring( 0, 8 ) );
                System.out.println( list );
            }, String.valueOf( i ) ).start();
        }
        //会生成java.util.ConcurrentModificationException
        //并发修改异常
        /**
         * 生成并发修改异常的原因是因为add方法中没有synchronized关键字
         */
    }

}

运行之后会生成java.util.ConcurrentModificationException，俗称并发修改异常

我们看一下add方法

/**
     * Appends the specified element to the end of this list.
     *
     * @param e element to be appended to this list
     * @return <tt>true</tt> (as specified by {@link Collection#add})
     */
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

此时我们发现add方法中没有synchronized关键字

那么我们如何去解决 List 类型的线程安全问题?

Vector

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

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

package com.thr_safety;

import java.util.UUID;
import java.util.Vector;

public class NotSafeDemo {
    public static void main(String[] args) {
        Vector<String> vector = new Vector<>();

        for (int i = 0; i < 30; i++) {
            new Thread( () ->{
                vector.add( UUID.randomUUID().toString().substring( 0,8 ) );
                System.out.println(vector);
            },String.valueOf( i )).start();
        }
    }
}

此时控制台输出没有问题，那么原理是什么呢？

我们看一下Vector类中的add方法

/**
     * Appends the specified element to the end of this Vector.
     *
     * @param e element to be appended to this Vector
     * @return {@code true} (as specified by {@link Collection#add})
     * @since 1.2
     */
    public synchronized boolean add(E e) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
    }

add 方法被 synchronized 同步修饰,线程安全!因此没有并发异常

Collections

Collections 提供了方法 synchronizedList 保证 list 是同步线程安全的

package com.thr_safety;

import java.util.*;

public class NotSafeDemo1 {
    public static void main(String[] args) {

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

        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();
        }
    }
}

没有并发修改异常

查看方法源码

/**
     * Returns a synchronized (thread-safe) list backed by the specified
     * list.  In order to guarantee serial access, it is critical that
     * <strong>all</strong> access to the backing list is accomplished
     * through the returned list.<p>
     *
     * It is imperative that the user manually synchronize on the returned
     * list when iterating over it:
     * <pre>
     *  List list = Collections.synchronizedList(new ArrayList());
     *      ...
     *  synchronized (list) {
     *      Iterator i = list.iterator(); // Must be in synchronized block
     *      while (i.hasNext())
     *          foo(i.next());
     *  }
     * </pre>
     * Failure to follow this advice may result in non-deterministic behavior.
     *
     * <p>The returned list will be serializable if the specified list is
     * serializable.
     *
     * @param  <T> the class of the objects in the list
     * @param  list the list to be "wrapped" in a synchronized list.
     * @return a synchronized view of the specified list.
     */
    public static <T> List<T> synchronizedList(List<T> list) {
        return (list instanceof RandomAccess ?
                new SynchronizedRandomAccessList<>(list) :
                new SynchronizedList<>(list));
    }

方法表明 synchronizedList 方法也是 List 接口中的方法，在里面可以传递List接口中的对象

CopyOnWriteArrayList(重点)

首先我们对 CopyOnWriteArrayList 进行学习,其特点如下:

它相当于线程安全的 ArrayList。和 ArrayList 一样，它是个可变数组；但是和

ArrayList 不同的时，它具有以下特性：

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

2,它是线程安全的。

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

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

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

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

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

3,复制思想：

当我们往一个容器添加元素的时候，不直接往当前容器添加，而是先将当前容器进行 Copy，复制出一个新的容器，然后新的容器里添加元素，添加完元素之后，再将原容器的引用指向新的容器。这时候会抛出来一个新的问题，也就是数据不一致的问题。如果写线程还没来得及写会内存，其他的线程就会读到了脏数据。

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

集合的线程安全问题集合操作 DemoVectorCollectionsCopyOnWriteArrayList(重点)HashSet 例子HashMap例子小结(重点)

通俗讲：

CopyWriteArrayList 写时复制技术

开始时，在集合中并发读取，当想写入内容的时候将最开始的读取内容复制一份，之后独立的在复制一份的内容，重新写入新的内容。

package com.thr_safety;

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

public class NotSafeDemo2 {
    public static void main(String[] args) {

        List<Object> 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();
        }
    }
}

HashSet 例子

package com.thr_safety;

import java.util.HashSet;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.CopyOnWriteArraySet;

public class NotSafeDemo3 {

    //测试HashSet 线程问题
    public static void main(String[] args) {
        //异常
       // Set<String> set = new HashSet<>();
        //解决方式
        Set<String> set = new CopyOnWriteArraySet<>();
        for (int i = 0; i < 30; i++) {
            new Thread(() ->{
                set.add( UUID.randomUUID().toString().substring( 0,8 ) );
                System.out.println(set);
            },String.valueOf( i )).start();
        }
    }
}

HashMap例子

package com.thr_safety;

import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;


public class NotSafeDemo4 {
    public static void main(String[] args) {
        //测试 HashMap 线程安全问题
       // HashMap<String, String> map = new HashMap<>();

        //解决并发修改异常问题
        Map<String, String> map = new ConcurrentHashMap<>();
        for (int i = 0; i < 30; i++) {
            String key = String.valueOf( i );
            new Thread( () -> {
                map.put( key, UUID.randomUUID().toString().substring( 0,8 ) );
                System.out.println(map);
            },String.valueOf( i )).start();
        }
    }
}

没有线程安全问题

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

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

"动态数组”机制

它内部有个“volatile 数组”(array)来保持数据。在“添加/修改/删除”数据时，都会新建一个数组，并将更新后的数据拷贝到新建的数组中，最后再将该数组赋值给“volatile 数组”, 这就是它叫做 CopyOnWriteArrayList 的原因
由于它在“添加/修改/删除”数据时，都会新建数组，所以涉及到修改数据的操作，CopyOnWriteArrayList 效率很低；但是单单只是进行遍历查找的话，效率比较高。

“线程安全”机制

通过 volatile 和互斥锁来实现的。
通过“volatile 数组”来保存数据的。一个线程读取 volatile 数组时，总能看到其它线程对该 volatile 变量最后的写入；就这样，通过 volatile 提供了“读取到的数据总是最新的”这个机制的保证。
通过互斥锁来保护数据。在“添加/修改/删除”数据时，会先“获取互斥锁”，再修改完毕之后，先将数据更新到“volatile 数组”中，然后再“释放互斥锁”，就达到了保护数据的目的。

小结(重点)

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

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

ArrayList ----- Vector

HashMap -----HashTable

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

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

3.java.util.concurrent 并发包下

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

END

集合的线程安全问题集合操作 DemoVectorCollectionsCopyOnWriteArrayList(重点)HashSet 例子HashMap例子小结(重点)

文章目录

集合操作 Demo

Vector

Collections

CopyOnWriteArrayList(重点)

HashSet 例子

HashMap例子

小结(重点)

继续阅读

关于Gradle配置的小结

Java小案例——随机数猜测随机数猜测

nginx location中斜线的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的简单使用

neo4j之cypher使用文档

GitHub连夜封杀！这份阿里 10W 字内部 Java 字面试手册到底有多强？

spark/scala关于【资源文件】加载方法概述外部文件加载方案测试资源文件打包入jar包中小结

mybatis_入门程序Mybatis入门

AOP编程_Android优雅权限框架(1)概念基础，2021金三银四前言正文大纲正文

Effective Java 8:通用程序设计

OOM三种类型

工厂模式-三种类型

【递归】高效率求2的n次幂

win10本地scala和spark安装安装scala安装spark

scala (3) Function 和 Method