多线程一直Java开发中的难点,也是面试中的常客,趁着还有时间,打算巩固一下JUC方面知识,我想机会随处可见,但始终都是留给有准备的人的,希望我们都能加油!!!
沉下去,再浮上来
,我想我们会变的不一样的。 JUC 系列
喜欢这样的天,暗暗的,又带着光
我想我们大家肯定都使用过ArrayList的吧。不知道你之前有没有想过它也会牵扯到线程安全问题勒。
我们一起先看看下面的程序吧,看你能看出什么问题吗?
public static void main(String[] args) {
List list = new ArrayList();
for (int i = 0; i < 20; i++) {
new Thread(() -> {
list.add(UUID.randomUUID().toString());
System.out.println(list);
}, "线程" + i).start();
}
}
你觉得能每次都能正常输出吗?
答案是否定的,也许好几次运行程序都不会出错,但是偶尔就会遇上一次的。会报一个ConcurrentModificationException
的异常,中文名为:并发修改异常。
原因:就是我们正在读的时候,正好也遇上了写操作,我们这里又没有同步代码块、锁什么的,那么此时肯定是不可以继续往下执行的。
还有ArrayList的add方法并非线程同步的。(jdk11源码)
public boolean add(E e) {
modCount++;
add(e, elementData, size);
return true;
}
我们该如何解决这个问题呢???
我们可以使用Vector
来代替ArrayList,因为Vector 继承了 AbstractList 类并且实现了List 、RandmoAccess 接口。
RandmoAccess
是 java 中用来被 List 实现,为 List 提供快速访问功能的。在 Vector 中,我们即可以通过元素的序号快速获取元素对象;这就是快速随机访 问。
public class Vector<E> extends AbstractList<E> implements List<E> ,RandomAccess
我们将上面的程序修改后,程序将不再出现异常。
public static void main(String[] args) {
List list = new Vector();
for (int i = 0; i < 20; i++) {
new Thread(() -> {
list.add(UUID.randomUUID().toString());
System.out.println(list);
}, "线程" + i).start();
}
}
原因其实就在 Vector 的代码中。
public synchronized boolean add(E e) {
modCount++;
add(e, elementData, elementCount);
return true;
}
add方法上加了synchronized
关键字,让这个方法成为了同步方法块。
Collections 提供了方法 synchronizedList 保证 list 是同步线程安全的。
Collections 仅包含对集合进行操作或返回集合的静态方法,所以我们通常也称Collections 为集合的工具类。
public static void main(String[] args) {
List list = Collections.synchronizedList(new ArrayList<>());
for (int i = 0; i < 20; i++) {
new Thread(() -> {
list.add(UUID.randomUUID().toString());
System.out.println(list);
}, "线程" + i).start();
}
}
这样也不会发生异常。源码上也都有体现
public void add(int index, E element) {
synchronized (mutex) {list.add(index, element);}
}
大多数方法都提供了同步和不同步两种api。
CopyOnWriteArrayList和ArrayList 一样,它是个可变数组。
有以下几个特点:
CopyOnWriteArrayList 的思想和原理:
当我们要添加一个元素的时候,不直接往当前容器中添加,而是应该先将当前容器复制一份,然后在新的容器中进行添加操作,等到添加完成后,我们再让原容器的引用指向新的容器。
当然,这个时候会抛出来一个新的问题,也就是数据不一致的问题。如果写线程还没来得及写进内存,那么其他的线程就会读到了脏数据。
public static void main(String[] args) {
List list = new CopyOnWriteArrayList();
for (int i = 0; i < 20; i++) {
new Thread(() -> {
list.add(UUID.randomUUID().toString());
System.out.println(list);
}, "线程" + i).start();
}
}
为什么不会产生线程安全问题呢?
我们从"动态数组"和“线程安全”两个方面来看待:
动态数组机制 :
它内部有个“volatile 数组”(array)来保持数据。在“添加/修改/删除”数据 时,都会新建一个数组,并将更新后的数据拷贝到新建的数组中,最后再将该 数组赋值给“volatile 数组”, 这就是它叫做 CopyOnWriteArrayList 的原因
它在“添加/修改/删除”数据时,都会新建数组,所以涉及到更新的操作,CopyOnWriteArrayList效率都会很低;但如果只是单单进行遍历查找的话, 效率能够达到比较高的。
public boolean add(E element) {
synchronized (lock) {
checkForComodification();
CopyOnWriteArrayList.this.add(offset + size, element);
expectedArray = getArray();
size++;
}
return true;
}
// CopyOnWriteArrayList.this.add(offset + size, element);
public void add(int index, E element) {
synchronized (lock) {
Object[] es = getArray();
int len = es.length;
if (index > len || index < 0)
throw new IndexOutOfBoundsException(outOfBounds(index, len));
Object[] newElements;
int numMoved = len - index;
if (numMoved == 0)
newElements = Arrays.copyOf(es, len + 1);
else {
newElements = new Object[len + 1];
System.arraycopy(es, 0, newElements, 0, index);
System.arraycopy(es, index, newElements, index + 1,
numMoved);
}
newElements[index] = element;
setArray(newElements);
}
}
线程安全机制:
通过 volatile 和互斥锁(synchronized)来实现的。
/** The array, accessed only via getArray/setArray. */
private transient volatile Object[] array;
通过“volatile 数组”来保存数据的
通过互斥锁来保护数据
另外补充
:
除了ArrayList是线程不安全的,还有HashMap、HashSet都是不安全的。
HashMap、HashSet的解决方式可以用Hashtable解决,当然不局限于这一种哈,(还没看完😂)
最近又开始了JUC的学习,感觉Java内容真的很多,但是为了能够走的更远,还是觉得应该需要打牢一下基础。
最近在持续更新中,如果你觉得对你有所帮助,也感兴趣的话,关注我吧,让我们一起学习,一起讨论吧。
你好,我是博主宁在春
,Java学习路上的一颗小小的种子,也希望有一天能扎根长成苍天大树。
希望与君共勉
😁
待我们,别时相见时,都已有所成。