Java并发编程之同步容器

简介

同步容器主要分两类，一种是vector这样的普通类，一种是通过collections的工厂方法创建的内部类

虽然很多人都对同步容器的性能低有偏见，但它也不是一无是处，在这里我们插播一条阿里巴巴的开发手册规范：

高并发时，同步调用应该去考量锁的性能损耗。能用无锁数据结构，就不要用锁；能锁区块，就不要锁整个方法体；能用对象锁，就不要用类锁。

可以看到，只有在高并发才会考虑到锁的性能问题，所以在一些小而全的系统中，同步容器还是有用武之地的（当然也可以考虑并发容器，后面章节再讨论）

一、什么是同步容器

定义：就是把容器类同步化，这样我们在并发中使用容器时，就不用手动同步，因为内部已经自动同步了

例子：比如vector就是一个同步容器类，它的同步化就是把内部的所有方法都上锁（有的重载方法没上锁，但是最终调用的方法还是有锁的）

源码：vector.add

// 通过synchronized为add方法上锁
public synchronized boolean add(e e) {
  modcount++;
  ensurecapacityhelper(elementcount + 1);
  elementdata[elementcount++] = e;
  return true;
}

同步容器主要分两类：

1.普通类：vector、stack、hashtable

2.内部类：collections创建的内部类，比如collections.synchronizedlist、 collections.synchronizedset等

那这两种有没有区别呢？

当然是有的，刚开始的时候(java1.0)只有第一种同步容器(vector等)

但是因为vector这种类太局气了，它就想着把所有的东西都弄过来自己搞(vector通过toarray转为己有,hashtable通过putall转为己有）；

源码：vector构造函数

public vector(collection<? extends e> c) {
	// 这里通过toarray将传来的集合 转为己有
  elementdata = c.toarray();
  elementcount = elementdata.length;
  // c.toarray might (incorrectly) not return object[] (see 6260652)
  if (elementdata.getclass() != object[].class)
    elementdata = arrays.copyof(elementdata, elementcount, object[].class);
}

所以就有了第二种同步容器类(通过工厂方法创建的内部容器类)，它就比较聪明了，它只是把原有的容器进行包装（通过this.list = list直接指向需要同步的容器)，然后局部加锁，这样一来，即生成了线程安全的类，又不用太费力；

源码：collections.synchronizedlist构造函数

synchronizedlist(list<e> list) {
  super(list);
  // 这里只是指向传来的list，不转为己有，后面的相关操作还是基于原有的list集合
  this.list = list;
}

他们之间的区别如下：

两种同步容器的区别	普通类	内部类
锁的对象	不可指定，只能this	可指定，默认this
锁的范围	方法体（包括迭代）	代码块（不包括迭代）
适用范围	窄-个别容器	广-所有容器

这里我们重点说下锁的对象：

• 普通类锁的是当前对象this（锁在方法上，默认this对象）；
• 内部类锁的是mutex属性，这个属性默认是this，但是可以通过构造函数（或工厂方法）来指定锁的对象

源码：collections.synchronizedcollection构造函数

final collection<e> c;  // backing collection
// 这个就是锁的对象
final object mutex;     // object on which to synchronize

synchronizedcollection(collection<e> c) {
  this.c = objects.requirenonnull(c);
// 初始化为 this
  mutex = this;
}

synchronizedcollection(collection<e> c, object mutex) {
  this.c = objects.requirenonnull(c);
  this.mutex = objects.requirenonnull(mutex);
}

这里要注意一点就是，内部类的迭代器没有同步(vector的迭代器有同步），需要手动加锁来同步

源码：vector.itr.next 迭代方法（有上锁）

public e next() {
  synchronized (vector.this) {
    checkforcomodification();
    int i = cursor;
    if (i >= elementcount)
      throw new nosuchelementexception();
    cursor = i + 1;
    return elementdata(lastret = i);
  }
}

源码：collections.synchronizedcollection.iterator 迭代器（没上锁）

public iterator<e> iterator() {
  // 这里会直接实现类的迭代器（比如arraylist，它里面的迭代器肯定是没上锁的）
  return c.iterator(); // must be manually synched by user!
}

二、为什么要有同步容器

因为普通的容器类（比如arraylist)是线程不安全的，如果是在并发中使用，我们就需要手动对其加锁才会安全，这样的话就很麻烦；

所以就有了同步容器，它来帮我们自动加锁

下面我们用代码来对比下

线程不安全的类：arraylist

public class synccollectiondemo {
    
    private list<integer> listnosync;

    public synccollectiondemo() {
        this.listnosync = new arraylist<>();
    }

    public void addnosync(int temp){
        listnosync.add(temp);
    }

    public static void main(string[] args) throws interruptedexception {
        synccollectiondemo demo = new synccollectiondemo();
				// 创建10个线程
        for (int i = 0; i < 10; i++) {
					// 每个线程执行100次添加操作
          new thread(()->{
                for (int j = 0; j < 1000; j++) {
                    demo.addnosync(j);
                }
            }).start();
        }
    }
}

上面的代码看似没问题，感觉就算有问题也应该是插入的顺序比较乱（多线程交替插入）

但实际上运行会发现，可能会报错数组越界，如下所示：

原因有二：

因为arraylist.add操作没有加锁，导致多个线程可以同时执行add操作add操作时，如果发现list的容量不足，会进行扩容，但是由于多个线程同时扩容，就会出现扩容不足的问题

源码：arraylist.grow扩容

// 扩容方法
private void grow(int mincapacity) {
        // overflow-conscious code
        int oldcapacity = elementdata.length;
				// 这里可以看到，每次扩容增加一半的容量
  			int newcapacity = oldcapacity + (oldcapacity >> 1);
        if (newcapacity - mincapacity < 0)
            newcapacity = mincapacity;
        if (newcapacity - max_array_size > 0)
            newcapacity = hugecapacity(mincapacity);
        // mincapacity is usually close to size, so this is a win:
        elementdata = arrays.copyof(elementdata, newcapacity);
    }

可以看到，扩容是基于之前的容量进行的，因此如果多个线程同时扩容，那扩容基数就不准确了，结果就会有问题

线程安全的类：collections.synchronizedlist

/**
 * <p>
 *  同步容器类：为什么要有它
 * </p>
 *
 * @author: javalover
 * @time: 2021/5/3
 */
public class synccollectiondemo {

    private list<integer> listsync;

    public synccollectiondemo() {
      	// 这里包装一个空的arraylist
        this.listsync = collections.synchronizedlist(new arraylist<>());
    }

    public void addsync(int j){
      	// 内部是同步操作: synchronized (mutex) {return c.add(e);}
        listsync.add(j);
    }

    public static void main(string[] args) throws interruptedexception {
        synccollectiondemo demo = new synccollectiondemo();

        for (int i = 0; i < 10; i++) {
            new thread(()->{
                for (int j = 0; j < 100; j++) {
                    demo.addsync(j);
                }
            }).start();
        }

        timeunit.seconds.sleep(1);
      	// 输出1000
        system.out.println(demo.listsync.size());
    }
}

输出正确，因为现在arraylist被collections包装成了一个线程安全的类

这就是为啥会有同步容器的原因：因为同步容器使得并发编程时，线程更加安全

三、同步容器的优缺点

一般来说，都是先说优点，再说缺点

但是我们这次先说优点

优点：

• 并发编程中，独立操作是线程安全的，比如单独的add操作

缺点（是的，优点已经说完了）：

• 性能差，基本上所有方法都上锁，完美的诠释了“宁可错杀一千，不可放过一个”
• 复合操作，还是不安全，比如putifabsent操作（如果没有则添加）
• 快速失败机制，这种机制会报错提示concurrentmodificationexception，一般出现在当某个线程在遍历容器时，其他线程恰好修改了这个容器的长度

为啥第三点是缺点呢？

因为它只能作为一个建议，告诉我们有并发修改异常，但是不能保证每个并发修改都会爆出这个异常

爆出这个异常的前提如下：

源码：vector.itr.checkforcomodification 检查容器修改次数

final void checkforcomodification() {
  // modcount：容器的长度变化次数， expectedmodcount：期望的容器的长度变化次数
  if (modcount != expectedmodcount)
    throw new concurrentmodificationexception();
}

那什么情况下并发修改不会爆出异常呢？有两种：

1.遍历没加锁的情况：对于第二种同步容器(collections内部类)来说，假设线程a修改了modcount的值，但是没有同步到线程b，那么线程b遍历就不会发生异常（但实际上问题已经存在了，只是暂时没有出现）

2.依赖线程执行顺序的情况：对于所有的同步容器来说，假设线程b已经遍历完了容器，此时线程a才开始遍历修改，那么也不会发生异常

代码就不贴了，大家感兴趣的可以直接写几个线程遍历试试，多运行几次，应该就可以看到效果(不过第一种情况也是基于理论分析，实际代码我这边也没跑出来)

根据阿里巴巴的开发规范：不要在 foreach 循环里进行元素的 remove/add 操作。remove 元素请使用 iterator方式，如果并发操作，需要对 iterator 对象加锁。

这里解释下，关于list.remove和iterator.remove的区别

• iterator.remove：会同步修改expectedmodcount=modcount
• list.remove：只会修改modcount，因为expectedmodcount属于iterator对象的属性，不属于list的属性（但是也可以间接访问）

源码：arraylist.remove移除元素操作

public e remove(int index) {
        rangecheck(index);
				// 1. 这里修改了 modcount
        modcount++;
        e oldvalue = elementdata(index);

        int nummoved = size - index - 1;
        if (nummoved > 0)
            system.arraycopy(elementdata, index+1, elementdata, index,
                             nummoved);
        elementdata[--size] = null; // clear to let gc do its work

        return oldvalue;
    }

源码：arraylist.itr.remove迭代器移除元素操作

public void remove() {
            if (lastret < 0)
                throw new illegalstateexception();
            checkforcomodification();

            try {
              	// 1. 这里调用上面介绍的list.romove，修改modcount
                arraylist.this.remove(lastret);
                cursor = lastret;
                lastret = -1;
              	// 2. 这里再同步更新 expectedmodcount
                expectedmodcount = modcount;
            } catch (indexoutofboundsexception ex) {
                throw new concurrentmodificationexception();
            }
        }

由于同步容器的这些缺点，于是就有了并发容器（下期来介绍）

四、同步容器的使用场景

多用在并发编程，但是并发量又不是很大的场景，比如一些简单的个人博客系统（具体多少并发量算大，这个也是分很多情况而论的，并不是说每秒处理超过多少个请求，就说是高并发，还要结合吞吐量、系统响应时间等多个因素一起考虑）

具体点来说的话，有以下几个场景：

• 写多读少，这个时候同步容器和并发容器的性能差别不大（并发容器可以并发读）
• 自定义的复合操作，比如getlast等操作（putifabsent就算了，因为并发容器有默认提供这个复合操作）
• 等等

总结

什么是同步容器：就是把容器类同步化，这样我们在并发中使用容器时，就不用手动同步，因为内部已经自动同步了

为什么要有同步容器：因为普通的容器类（比如arraylist)是线程不安全的，如果是在并发中使用，我们就需要手动对其加锁才会安全，这样的话就很太麻烦；所以就有了同步容器，它来帮我们自动加锁

同步容器的优缺点：

优点 独立操作，线程安全

缺点 复合操作，还是不安全，性能差快速失败机制，只适合bug调试

同步容器的使用场景

多用在并发量不是很大的场景，比如个人博客、后台系统等

具体点来说，有以下几个场景：

• 写多读少：这个时候同步容器和并发容器差别不是很大
• 自定义复合操作：比如getlast等复合操作，因为同步容器都是单个操作进行上锁的，所以可以很方便地去拼接复合操作（记得外部加锁）

到此这篇关于java并发编程之同步容器的文章就介绍到这了,更多相关java同步容器内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！