Java并发学习（三）-关于并发下ArrayList及HashMap的问题描述及处理

最新推荐文章于 2021-05-14 10:09:39 发布

丨Anna丨

最新推荐文章于 2021-05-14 10:09:39 发布

阅读量396

点赞数

分类专栏： Java # Java并发学习

本文链接：https://blog.csdn.net/u014331138/article/details/100103757

版权

Java 同时被 2 个专栏收录

8 篇文章 0 订阅

订阅专栏

Java并发学习

4 篇文章 0 订阅

订阅专栏

关于并发下ArrayList及HashMap的问题描述及处理

并发下的ArrayList

ArrayList是一个线程不安全的容器。如果在多线程中使用ArrayList，可能会导致程序出错。首先我们看一下以下代码：

package com.test.arrayList;

import java.util.ArrayList;

/**
 * ArrayList是一个线程不安全的容器。如果在多线程中使用ArrayList，可能会导致程序出错。
 * @author Anna.
 */
public class ThreadArrayListTest {
    public static void main(String[] args) {
        Data data = new Data();
        AddThread addThread = new AddThread(data);
        Thread th = new Thread(addThread);
        Thread th2 = new Thread(addThread);
        th.setName("甲");
        th2.setName("乙");
        th.start();
        th2.start();
        try {
            th.join();
            th2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("List size:" + data.getList().size());
    }
}

class Data {
    ArrayList<Integer> list = new ArrayList<Integer>();
    public ArrayList<Integer> getList() {
        return list;
    }
    public void setList(ArrayList<Integer> list) {
        this.list = list;
    }

}

class AddThread implements Runnable {
    Data data;
    public AddThread(Data data) {
        this.data = data;
    }
    @Override
    public void run() {
        for (int i = 0; i < 100000; i++){
            data.getList().add(i);
        }
    }
}

可能出现的结果如下：

（1）程序正确结束，ArrayList大小确实为200000个。这说明即使并发程序有问题，也未必会每次表现出来；

（2）程序抛出下标越界异常。如下：

原因分析：当一个线程在ArrayList扩容的过程中，参与进来，线程获取的大小为未扩容时的大小，由于没有锁的保护，导致其内部一致性被破坏，导致出现越界问题。

（3）程序不抛出异常，但是ArrayList集合大小小于200000个，如图：

原因分析：这是由于多线程访问冲突，是的保存容器大小的变量被多线程不正常的访问，同一时间两个线程对ArrayList中的一个位置进行赋值导致的。

解决办法

（1）使用线程安全的Vector代替ArrayList。相对于ArrayList于Vector都是使用数组作为其内部实现，不同的是ArrayList是线程不安全的，Vector是线程安全的。代码如下：

package com.test.arrayList;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Vector;

/**
 * ArrayList是一个线程不安全的容器。如果在多线程中使用ArrayList，可能会导致程序出错。
 * 使用线程安全的Vector代替ArrayList
 * @author Anna.
 */
public class ThreadArrayListTest02 {
    public static void main(String[] args) {
        Data02 data = new Data02();
        AddThread02 addThread = new AddThread02(data);
        Thread th = new Thread(addThread);
        Thread th2 = new Thread(addThread);
        th.setName("甲");
        th2.setName("乙");
        th.start();
        th2.start();
        try {
            th.join();
            th2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Vector size:" + data.getVector().size());
    }
}

class Data02 {
    private Vector vector = new Vector(10);
    public Vector getVector() {
        return vector;
    }
    public void setVector(Vector vector) {
        this.vector = vector;
    }
}

class AddThread02 implements Runnable {
    Vector vector;
    public AddThread02(Data02 data) {
        this.vector = data.getVector();
    }
    @Override
    public void run() {
        for (int i = 0; i < 100000; i++){
            vector.addElement(i);
        }
    }
}

Vector与ArrayList之间的相互转换

Vector v = new Vector();
ArrayList ar = new ArrayList();
Collections.copy(ar, v);

（2）使用Collections的synchronizedList方法将其转换为线程安全的容器再使用。同样，LinkedList使用链表结构实现的List，同样可以使用该方法将其转换为安全的容器在使用。代码如下：

package com.test.arrayList;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * ArrayList是一个线程不安全的容器。如果在多线程中使用ArrayList，可能会导致程序出错。
 * 使用Collections的synchronizedList方法将其转换为线程安全的容器再使用
 * @author Anna.
 */
public class ThreadArrayListTest02 {
    public static void main(String[] args) {
        Data02 data = new Data02();
        AddThread02 addThread = new AddThread02(data);
        Thread th = new Thread(addThread);
        Thread th2 = new Thread(addThread);
        th.setName("甲");
        th2.setName("乙");
        th.start();
        th2.start();
        try {
            th.join();
            th2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
//        for(int i = 0; i < 200000;i++){
//            System.out.println("List :" + data.getList().get(i));
//        }
        System.out.println("List size:" + data.getList().size());
    }
}

class Data02 {
    ArrayList<Integer> list = new ArrayList<Integer>();
    public ArrayList<Integer> getList() {
        return list;
    }
    public void setList(ArrayList<Integer> list) {
        this.list = list;
    }

}

class AddThread02 implements Runnable {
    List<Integer> list;
    public AddThread02(Data02 data) {
        this.list = Collections.synchronizedList(data.getList());
    }

    public List<Integer> getList() {
        return list;
    }
    public void setList(List<Integer> list) {
        this.list = list;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100000; i++){
            list.add(i);
        }
    }
}

并发下的HashMap

并发下的HashMap同样是线程不安全的。如果在多线程中使用ArrayList，可能会导致程序出错。首先我们看一下以下代码：

package com.test.hashMap;

import java.util.ArrayList;
import java.util.Map;

/**
 * HashMap同样是线程不安全的。如果在多线程中使用HashMap，可能会导致程序出错。
 * @author Anna.
 */
public class ThreadHashMapTest {
    public static void main(String[] args) {
        Data data = new Data();
        AddThread addThread = new AddThread(data);
        Thread th = new Thread(addThread);
        Thread th2 = new Thread(addThread);
        th.setName("甲");
        th2.setName("乙");
        th.start();
        th2.start();
        try {
            th.join();
            th2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Map size:" + data.getMap().size());
    }
}

class Data {
    private Map<String,String> map;
    public Map<String, String> getMap() {
        return map;
    }
    public void setMap(Map<String, String> map) {
        this.map = map;
    }
}

class AddThread implements Runnable {
    Data data;
    public AddThread(Data data) {
        this.data = data;
    }
    @Override
    public void run() {
        for (int i = 0; i < 100000; i++){
            data.getMap().put(Integer.toString(i),String.valueOf(i));
        }
    }
}

可能出现的结果如下：

（1）程序正常结束，并且结果符合预期，HashMap的大小为200000

（2）程序正常结束，但结果不符合预期，而是一个小于200000的值。

（3）程序进入死循环。（可能造成电脑死机，该类较小，谨慎尝试）

原因分析：

出现前两种情况，与ArrayList类似。但是第三种，是因为多线程在遍历HashMap的内部数据时，形成死循环导致。

解决办法

（1）使用Collections.synchronizedMap()方法包装HashMap。如下产生的HashMap就是线程安全的。虽然通过Collections.synchronizedMap 来生成一个线程安全的 Map 实例, 但这是全局锁方式, 性能会有所不及;

public static Map map = Collections.synchronizedMap(new HashMap());

针对上述问题，解决代码如下：

package com.test.hashMap;

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

/**
 * HashMap同样是线程不安全的。如果在多线程中使用HashMap，可能会导致程序出错。
 * 使用Collections.synchronizedMap()方法包装HashMap。产生的HashMap就是线程安全的
 * @author Anna.
 */
public class ThreadHashMapTest02 {
    public static void main(String[] args) {
        Data data = new Data();
        AddThread addThread = new AddThread(data);
        Thread th = new Thread(addThread);
        Thread th2 = new Thread(addThread);
        th.setName("甲");
        th2.setName("乙");
        th.start();
        th2.start();
        try {
            th.join();
            th2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
//        for (int i = 0; i < 100000;i++) {
//            System.out.println("Map Value:" + data.getMap().get(Integer.toString(i)));
//        }
        System.out.println("Map size:" + data.getMap().size());
    }
}

class Data {
    private Map<String,String> map = new HashMap<String, String>();
    public Map<String, String> getMap() {
        return map;
    }
    public void setMap(Map<String, String> map) {
        this.map = map;
    }
}

class AddThread implements Runnable {
    Map map;
    public AddThread(Data data) {
        this.map = Collections.synchronizedMap(data.getMap());
    }
    @Override
    public void run() {
        for (int i = 0; i < 100000; i++){
            map.put(Integer.toString(i),String.valueOf(i));
        }
    }
}

（2）使用ConcurrentHashMap类代替HashMap，通过减小锁的粒度（所谓减小锁粒度是指缩小锁定对象的范围，从而降低锁冲突的可能性，进而提高系统的并发能力）的方式削弱多线程竞争。这种技术典型的使用场景就是ConcurrentHashMap类的实现。

ConcurrentHashMap类内不进一步细分为若干个晓得HashMap，称之为段。在默认的情况下，一个ConcurrentHashMap类可以被细分为16段。因此ConcurrentHashMap类可以接受16个线程同时插入（如果都插入不同的段中），从而大大提升其吞吐量。

ConcurrentHashMap类虽然其put()方法很好的分离了锁，但是当试图访问ConcurrentHashMap类的全局信息时，就需要同时取得所有段的方法才能顺利实施，因此，减小粒度的方式，当系统需要获取全局锁时，其消耗的资源是比较多的。

因此，只有在类似于size()方法获取全局信息的方法调用并不频繁时，这种减小锁粒度的方法才能真正意义上提高系统的吞吐量。

具体参考：《Java并发包concurrent——ConcurrentHashMap》

丨Anna丨

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java并发学习（三）-关于并发下ArrayList及HashMap的问题描述及处理

关于并发下ArrayList及HashMap的问题描述及处理并发下的ArrayList ArrayList是一个线程不安全的容器。如果在多线程中使用ArrayList，可能会导致程序出错。首先我们看一下以下代码：package com.test.arrayList;import java.util.ArrayList;/** * ArrayList是一个线程不安全的...
复制链接

扫一扫