Java多线程理解：线程安全的集合对象

编程语言 2018-05-12 07:43:51 阅读次数: 1

1、概念介绍

  • 线程安全就是多线程访问时，采用了加锁机制，当一个线程访问该类的某个数据时，进行保护，其他线程不能进行访问直到该线程读取完，其他线程才可使用。不会出现数据不一致或者数据污染。
  • 线程不安全就是不提供数据访问保护，多线程先后更改数据会产生数据不一致或者数据污染的情况。
  • 一般使用synchronized关键字加锁同步控制，来解决线程不安全问题。

2、线程安全的集合对象

  • ArrayList线程不安全，Vector线程安全；
  • HashMap线程不安全，HashTable线程安全；
  • StringBuilder线程不安全，StringBuffer线程安全。

3、代码测试

  • ArrayList线程不安全：
    在主线程中新建100个子线程，分别向ArrayList中添加100个元素，最后打印ArrayList的size。

    public class Test {

public static void main(String [] args){
 // 用来测试的List  
 List<String> data = new ArrayList<>();
 // 用来让主线程等待100个子线程执行完毕  
 CountDownLatch countDownLatch = new CountDownLatch(100);
 // 启动100个子线程  
 for(int i=0;i<100;i++){
     SampleTask task = new SampleTask(data,countDownLatch);
     Thread thread = new Thread(task);
     thread.start();
 }
 try{
     // 主线程等待所有子线程执行完成，再向下执行  
     countDownLatch.await();
 }catch (InterruptedException e){  
     e.printStackTrace();  
 } 
 // List的size  
 System.out.println(data.size());
}
}
class SampleTask implements Runnable {
CountDownLatch countDownLatch;
List<String> data;
public SampleTask(List<String> data,CountDownLatch countDownLatch){
   this.data = data;
   this.countDownLatch = countDownLatch;
}
@Override
public void run() {
   // 每个线程向List中添加100个元素  
   for(int i = 0; i < 100; i++)  
   {  
       data.add("1");
   }  
   // 完成一个子线程  
   countDownLatch.countDown();
}
}

    7次测试输出()：

    9998
10000
10000
ArrayIndexOutOfBoundsException
10000
9967
9936

  • Vector线程安全：
    在主线程中新建100个子线程，分别向Vector中添加100个元素，最后打印Vector的size。

    public class Test {

public static void main(String [] args){
 // 用来测试的List  
 List<String> data = new Vector<>();
 // 用来让主线程等待100个子线程执行完毕  
 CountDownLatch countDownLatch = new CountDownLatch(100);
 // 启动100个子线程  
 for(int i=0;i<100;i++){
     SampleTask task = new SampleTask(data,countDownLatch);
     Thread thread = new Thread(task);
     thread.start();
 }
 try{
     // 主线程等待所有子线程执行完成，再向下执行  
     countDownLatch.await();
 }catch (InterruptedException e){  
     e.printStackTrace();  
 } 
 // List的size  
 System.out.println(data.size());
}
}
class SampleTask implements Runnable {
CountDownLatch countDownLatch;
List<String> data;
public SampleTask(List<String> data,CountDownLatch countDownLatch){
   this.data = data;
   this.countDownLatch = countDownLatch;
}
@Override
public void run() {
   // 每个线程向List中添加100个元素  
   for(int i = 0; i < 100; i++)  
   {  
       data.add("1");
   }  
   // 完成一个子线程  
   countDownLatch.countDown();
}
}

    7次测试输出()：

    10000
10000
10000
10000
10000
10000
10000

  • 使用synchronized关键字来同步ArrayList：

    public class Test {

public static void main(String [] args){
 // 用来测试的List  
 List<String> data = new ArrayList<>();
 // 用来让主线程等待100个子线程执行完毕  
 CountDownLatch countDownLatch = new CountDownLatch(100);
 // 启动100个子线程  
 for(int i=0;i<100;i++){
     SampleTask task = new SampleTask(data,countDownLatch);
     Thread thread = new Thread(task);
     thread.start();
 }
 try{
     // 主线程等待所有子线程执行完成，再向下执行  
     countDownLatch.await();
 }catch (InterruptedException e){  
     e.printStackTrace();  
 } 
 // List的size  
 System.out.println(data.size());
}
}
class SampleTask implements Runnable {
CountDownLatch countDownLatch;
List<String> data;
public SampleTask(List<String> data,CountDownLatch countDownLatch){
   this.data = data;
   this.countDownLatch = countDownLatch;
}
@Override
public void run() {
   // 每个线程向List中添加100个元素  
   for(int i = 0; i < 100; i++)  
   {  
       synchronized(data){
           data.add("1");
       }
   }  
   // 完成一个子线程  
   countDownLatch.countDown();
}
}

    7次测试输出()：

    10000
10000
10000
10000
10000
10000
10000

3、原因分析

  • ArrayList在添加一个元素的时候，它会有两步来完成：1. 在 Items[Size] 的位置存放此元素；2. 增大 Size 的值。
    在单线程运行的情况下，如果 Size = 0，添加一个元素后，此元素在位置 0，而且 Size=1；
    而如果是在多线程情况下，比如有两个线程，线程 A 先将元素1存放在位置 0。但是此时 CPU 调度线程A暂停，线程 B 得到运行的机会。线程B向此 ArrayList 添加元素2，因为此时 Size 仍然等于 0 （注意，我们假设的是添加一个元素是要两个步骤，而线程A仅仅完成了步骤1），所以线程B也将元素存放在位置0。然后线程A和线程B都继续运行，都增加 Size 的值，结果Size都等于1。
    最后，ArrayList中期望的元素应该有2个，而实际元素是在0位置，造成丢失元素，故Size 等于1。导致“线程不安全”。
    ArrayList源码： 
    @Override public boolean add(E object) {
      Object[] a = array;
      int s = size;
      if (s == a.length) {
          Object[] newArray = new Object[s +
                  (s < (MIN_CAPACITY_INCREMENT / 2) ?
                   MIN_CAPACITY_INCREMENT : s >> 1)];
          System.arraycopy(a, 0, newArray, 0, s);
          array = a = newArray;
      }
      a[s] = object;
      size = s + 1;
      modCount++;
      return true;
  }
  • Vector的所有操作方法都被同步了，既然被同步了，多个线程就不可能同时访问vector中的数据，只能一个一个地访问，所以不会出现数据混乱的情况，所以是线程安全的。
    Vector源码： 
    @Override
  public synchronized boolean add(E object) {
      if (elementCount == elementData.length) {
          growByOne();
      }
      elementData[elementCount++] = object;
      modCount++;
      return true;
  }

4、线程安全的集合并不安全

分析以下场景：

synchronized(map){
Object value = map.get(key);
if(value == null)
{
    value = new Object();
    map.put(key,value);
}
return value;}

由于线程安全的集合对象是基于单个方法的同步，所以即使map是线程安全的，也会产生不同步现象。
在非单个方法的场景下，我们仍然需要使用synchronized加锁才能保证对象的同步。

代码测试：

public class Test {

  public static void main(String [] args){
      // 用来测试的List  
      List<String> data = new Vector<>();
      // 用来让主线程等待100个子线程执行完毕  
      CountDownLatch countDownLatch = new CountDownLatch(100);
      // 启动100个子线程  
      for(int i=0;i<1000;i++){
          SampleTask task = new SampleTask(data,countDownLatch);
          Thread thread = new Thread(task);
          thread.start();
      }
      try{
          // 主线程等待所有子线程执行完成，再向下执行  
          countDownLatch.await();
      }catch (InterruptedException e){  
          e.printStackTrace();  
      } 
      // List的size  
      System.out.println(data.size());
  }
}
class SampleTask implements Runnable {
    CountDownLatch countDownLatch;
    List<String> data;
    public SampleTask(List<String> data,CountDownLatch countDownLatch){
        this.data = data;
        this.countDownLatch = countDownLatch;
    }
    @Override
    public void run() {
        // 每个线程向List中添加100个元素  
        int size = data.size();
        data.add(size,"1"); 
        // 完成一个子线程  
        countDownLatch.countDown();
    }
}
997
993
995
996
997
998
997

5、总结

  • 如何取舍
    线程安全必须要使用synchronized关键字来同步控制，所以会导致性能的降低。
    当不需要线程安全时，可以选择ArrayList，避免方法同步产生的开销；
    当多个线程操作同一个对象时，可以选择线程安全的Vector；
  • 线程不安全!=不安全
    有人在使用过程中有一个不正确的观点：我的程序是多线程的，不能使用ArrayList要使用Vector，这样才安全。
    线程不安全并不是多线程环境下就不能使用。
    注意线程不安全条件：多线程操作同一个对象。比如上述代码就是在多个线程操作同一个ArrayList对象。
    如果每个线程中new一个ArrayList，而这个ArrayList只在这一个线程中使用，那么是没问题的。
  • 线程‘安全’的集合对象
    较复杂的操作下，线程安全的集合对象也无法保证数据的同步，仍然需要我们来处理。



文／梦工厂（简书作者）
原文链接：http://www.jianshu.com/p/eccb5f350c12
著作权归作者所有，转载请联系作者获得授权，并标注“简书作者”。

猜你喜欢

转载自jaesonchen.iteye.com/blog/2328279
今日推荐
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
周排行
让自己的头脑极度开放
CentOS 6.5(x64) 和Redhat6.5操作系误删libc
高可用注册中心
【日记】12.28/【题解】AtCoder AGC041
XML（5）_XML 约束_DTD
Java集合Map（四）
树梅派安装桌面环境教程
pipenv 的 使用和安装
小程序白屏问题和内存研究
C语言简单选择排序
每日归档
更多
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022