线程安全的集合java

1. java的collection中哪些是线程安全的

java集合框架提供了多种synchronized集合, 比如Vector, HashTable, Collections的synchronizedXxx方法的返回值等.
synchronized集合是线程安全的, 但不是严格线程安全的. 根据JCIP第二章关于线程安全的定义--线程安全的类无需调用方进行额外的同步--synchronized集合是不满足该定义的. 如果我们将线程安全的定义放宽一些--单次调用对象的方法而无需调用方进行额外的同步, 这样synchronized集合就符合定义了.

2. Java集合中哪些类是线程安全的

线程安全类

在集合框架中，有些类是线程安全的，这些都是jdk1.1中的出现的。在jdk1.2之后，就出现许许多多非线程安全的类。 下面是这些线程安全的同步的类：

vector：就比arraylist多了个同步化机制（线程安全），因为效率较低，现在已经不太建议使用。在web应用中，特别是前台页面，往往效率（页面响应速度）是优先考虑的。

statck：堆栈类，先进后出

hashtable：就比hashmap多了个线程安全

enumeration：枚举，相当于迭代器

除了这些之外，其他的都是非线程安全的类和接口。

线程安全的类其方法是同步的，每次只能一个访问。是重量级对象，效率较低。

其他：

1. hashtable跟hashmap的区别

hashtable是线程安全的,即hashtable的方法都提供了同步机制；hashmap不是线程安全的,即不提供同步机制 ；hashtable不允许插入空值,hashmap允许!

2. 多线程并发修改一 个 集合 怎么办

用老的Vector/Hashtable类

StringBuffer是线程安全，而StringBuilder是线程不安全的。对于安全与不安全没有深入的理解情况下，易造成这样的错觉，如果对于StringBuffer的操作均是线程安全的，然而，Java给你的保证的线程安全，是说它的方法是执行是排它的，而不是对这个对象本身的多次调用情况下，还是安全的。看看下边的例子，在StringBufferTest中有一个数据成员contents它是用来扩展的，它的每一次append是线程安全的，但众多次append的组合并不是线程安全的，这个输出结果不是太可控的，但如果对于log和getContest方法加关键字synchronized，那么结果就会变得非常条理，如果换成StringBuider甚至是append到一半，它也会让位于其它在此基础上操作的线程：

3. java线程安全的集合不能保证线程安全

仅能保证单个操作是线程安全的，但是迭代器则不再此列。
另外“组合操作”也是不能保证安全的。
如
if(proct.size()<10){
proct.add("obj");
}
不能保证proct.size()之后，proct.add("obj")之前，另外一个线程不add别的数据。
也不能保证
if (proct.contains("apple")) {
int index = proct.indexOf("apple");
proct.set(index, "banana");
}
确认有apple，就能查到apple的下标，即便是查到有效的下标，也不能保证set时，该下标仍然有效。

4. 如何保证集合是线程安全的

并发（concurrency）一个并不陌生的词，简单来说，就是cpu在同一时刻执行多个任务。
而Java并发则由多线程实现的。
在jvm的世界里，线程就像不相干的平行空间，串行在虚拟机中。（当然这是比较笼统的说法，线程之间是可以交互的，他们也不一定是串行。）
多线程的存在就是压榨cpu，提高程序性能，还能减少一定的设计复杂度（用现实的时间思维设计程序）。
这么说来似乎线程就是传说中的银弹了，可事实告诉我们真正的银弹并不存在。
多线程会引出很多难以避免的问题， 如死锁，脏数据，线程管理的额外开销，等等。更大大增加了程序设计的复杂度。
但他的优点依旧不可替代。

死锁和脏数据就是典型的线程安全问题。
简单来说，线程安全就是： 在多线程环境中，能永远保证程序的正确性。
只有存在共享数据时才需要考虑线程安全问题。
java内存区域：

其中， 方法区和堆就是主要的线程共享区域。那么就是说共享对象只可能是类的属性域或静态域。

了解了线程安全问题的一些基本概念后， 我们就来说说如何解决线程安全问题。我们来从一个简单的servlet示例来分析：public class ReqCounterServlet extends HttpServlet{ private int count = 0;
public void doGet(HttpServletRequest request,
HttpServletResponse response) throws IOException, ServletException {
count++;
System.out.print("当前已达到的请求数为" + count);
}
public void doPost(HttpServletRequest request,
HttpServletResponse response) throws IOException, ServletException { // ignore }
}1. 了解业务场景的线程模型
这里的线程模型指的是: 在该业务场景下， 可能出现的线程调用实况。
众所周知，Servlet是被设计为单实例，在请求进入tomcat后，由Connector建立连接，再讲请求分发给内部线程池中的Processor，
此时Servlet就处于一个多线程环境。即如果存在几个请求同时访问某个servlet，就可能会有几个线程同时访问该servlet对象。如图：

线程模型，如果简单的话，就在脑海模拟一下就好了，复杂的话就可以用纸笔或其他工具画出来。

2. 找出共享对象
这里的共享对象就很明显就是ReqCounterServlet。

3. 分析共享对象的不变性条件
不变性条件，这个名词是在契约式编程的概念中的。不变性条件保证类的状态在任何功能被执行后都保持在一个可接受的状态。
这里可以引申出， 不可变对象是线程安全的。（因为不可变对象就没有不变性条件）
不变性条件则主要由对可变状态的修改与访问构成。
这里的servlet很简单， 不变性条件大致可以归纳为： 每次请求进入时count计数必须加一，且计数必须正确。
在复杂的业务中， 类的不变性条件往往很难考虑周全。设计的世界是险恶的，只能小心谨慎，用测量去证明，最大程度地减少错误出现的几率。

4. 用特定的策略解决线程安全问题。
如何解决的确是该流程的重点。目前分三种方式解决：
第一种，修改线程模型。即不在线程之间共享该状态变量。一般这个改动比较大，需要量力而行。
第二种，将对象变为不可变对象。有时候实现不了。
第三种，就比较通用了，在访问状态变量时使用同步。 synchronized和Lock都可以实现同步。简单点说，就是在你修改或访问可变状态时加锁，独占对象，让其他线程进不来。
这也算是一种线程隔离的办法。（这种方式也有不少缺点，比如说死锁，性能问题等等）

其实有一种更好的办法，就是设计线程安全类。《代码大全》就有提过，问题解决得越早，花费的代价就越小。
是的，在设计时，就考虑线程安全问题会容易的多。
首先考虑该类是否会存在于多线程环境。如果不是，则不考虑线程安全。
然后考虑该类是否能设计为不可变对象，或者事实不可变对象。如果是，则不考虑线程安全
最后，根据流程来设计线程安全类。
设计线程安全类流程：
1、找出构成对象状态的所有变量。
2、找出约束状态变量的不变性条件。
3、建立对象状态的并发访问管理策略。

有两种常用的并发访问管理策略：
1、java监视器模式。 一直使用某一对象的锁来保护某状态。
2、线程安全委托。 将类的线程安全性委托给某个或多个线程安全的状态变量。（注意多个时，这些变量必须是彼此独立，且不存在相关联的不变性条件。）

5. Java的List如何实现线程安全

Java的List如何实现线程安全？

Collections.synchronizedList(names);效率最高，线程安全

Java的List是我们平时很常用的集合，线程安全对于高并发的场景也十分的重要，那么List如何才能实现线程安全呢 ？

加锁

首先大家会想到用Vector，这里我们就不讨论了，首先讨论的是加锁，例如下面的代码

public class Synchronized{

private List<String> names = new LinkedList<>();

public synchronized void addName(String name ){
names.add("abc");
}
public String getName(Integer index){
Lock lock =new ReentrantLock();
lock.lock();
try {
return names.get(index);
}catch (Exception e){
e.printStackTrace();
}
finally {
lock.unlock();
}
return null;
}
}

synchronized一加，或者使用lock 可以实现线程安全，但是这样的List要是很多个，代码量会大大增加。

java自带类

在java中我找到自带有两种方法

CopyOnWriteArrayList

CopyOnWrite 写入时复制，它使一个List同步的替代品，通常情况下提供了更好的并发性，并且避免了再迭代时候对容器的加锁和复制。通常更适合用于迭代，在多插入的情况下由于多次的复制性能会一定的下降。

下面是add方法的源代码

public boolean add(E e) {
final ReentrantLock lock = this.lock; // 加锁 只允许获得锁的线程访问
lock.lock();
try {
Object[] elements = getArray();
int len = elements.length;
// 创建个长度加1的数组并复制过去
Object[] newElements = Arrays.Of(elements, len + 1);
newElements[len] = e; // 赋值
setArray(newElements); // 设置内部的数组
return true;
} finally {
lock.unlock();
}
}

Collections.synchronizedList

Collections中有许多这个系列的方法例如

主要是利用了装饰者模式对传入的集合进行调用 Collotions中有内部类SynchronizedList

static class SynchronizedList<E>
extends SynchronizedCollection<E>
implements List<E> {
private static final long serialVersionUID = -7754090372962971524L;

final List<E> list;

SynchronizedList(List<E> list) {
super(list);
this.list = list;
}
public E get(int index) {
synchronized (mutex) {return list.get(index);}
}
public E set(int index, E element) {
synchronized (mutex) {return list.set(index, element);}
}
public void add(int index, E element) {
synchronized (mutex) {list.add(index, element);}
}
public E remove(int index) {
synchronized (mutex) {return list.remove(index);}
}

static class SynchronizedCollection<E> implements Collection<E>, Serializable {
private static final long serialVersionUID = 3053995032091335093L;

final Collection<E> c; // Backing Collection
final Object mutex; // Object on which to synchronize

这里上面的mutex就是锁的对象 在构建时候可以指定锁的对象 主要使用synchronize关键字实现线程安全

/**
* @serial include
*/
static class SynchronizedList<E>
extends SynchronizedCollection<E>
implements List<E> {
private static final long serialVersionUID = -7754090372962971524L;

final List<E> list;

SynchronizedList(List<E> list) {
super(list);
this.list = list;
}
SynchronizedList(List<E> list, Object mutex) {
super(list, mutex);
this.list = list;
}
这里只是列举SynchronizedList ，其他类类似，可以看下源码了解下。

测试
public class Main {
public static void main(String[] args) {
List<String> names = new LinkedList<>();
names.add("sub");
names.add("jobs");
// 同步方法1 内部使用lock
long a = System.currentTimeMillis();
List<String> strings = new CopyOnWriteArrayList<>(names);
for (int i = 0; i < 100000; i++) {
strings.add("param1");
}
long b = System.currentTimeMillis();
// 同步方法2 装饰器模式使用 synchronized
List<String> synchronizedList = Collections.synchronizedList(names);
for (int i = 0; i < 100000; i++) {
synchronizedList.add("param2");
}
long c = System.currentTimeMillis();
System.out.println("CopyOnWriteArrayList time == "+(b-a));
System.out.println("Collections.synchronizedList time == "+(c-b));
}
}

两者内部使用的方法都不一样，CopyOnWriteArrayList内部是使用lock进行加锁解锁完成单线程访问，synchronizedList使用的是synchronize

进行了100000次添加后时间对比如下：

可以看出来还是使用了synchronize的集合工具类在添加方面更加快一些，其他方法这里篇幅关系就不测试了，大家有兴趣去试一下。

6. java线程安全的集合还要加锁吗

线程安全是指要控制多个线程对某个资源的有序访问或修改，而在这些线程之间没有产生冲突。 在Java里，线程安全一般体现在两个方面： 1、多个thread对同一个java实例的访问（read和modify）不会相互干扰，它主要体现在关键字synchronized。

7. Java哪些集合类是线程安全的

在集合框架中，有些类是线程安全的，这些都是jdk1.1中的出现的。在jdk1.2之后，就出现许许多多非线程安全的类。 下面是这些线程安全的同步的类：
vector：就比arraylist多了个同步化机制（线程安全），因为效率较低，现在已经不太建议使用。在web应用中，特别是前台页面，往往效率（页面响应速度）是优先考虑的。
statck：堆栈类，先进后出
hashtable：就比hashmap多了个线程安全
enumeration：枚举，相当于迭代器
除了这些之外，其他的都是非线程安全的类和接口。
线程安全的类其方法是同步的，每次只能一个访问。是重量级对象，效率较低。
其他：
1. hashtable跟hashmap的区别
hashtable是线程安全的,即hashtable的方法都提供了同步机制；hashmap不是线程安全的,即不提供同步机制 ；hashtable不允许插入空值,hashmap允许!

8. java集合类中哪些是线程安全的

一些历史类的一般是线程安全的，例如：Vector,HashTable等
在jdk升级后，出现了替代一些集合的类，ArrayList，HashMap等，一般都是线程不安全的。

9. 如何保证集合是线程安全的

1、不可变

在java语言中，不可变的对象一定是线程安全的，无论是对象的方法实现还是方法的调用者，都不需要再采取任何的线程安全保障措施。如final关键字修饰的数据不可修改，可靠性最高。

2、绝对线程安全

绝对的线程安全完全满足Brian GoetZ给出的线程安全的定义，这个定义其实是很严格的，一个类要达到“不管运行时环境如何，调用者都不需要任何额外的同步措施”通常需要付出很大的代价。

3、相对线程安全

相对线程安全就是我们通常意义上所讲的一个类是“线程安全”的。

它需要保证对这个对象单独的操作是线程安全的，我们在调用的时候不需要做额外的保障措施，但是对于一些特定顺序的连续调用，就可能需要在调用端使用额外的同步手段来保证调用的正确性。

在java语言中，大部分的线程安全类都属于相对线程安全的，例如Vector、HashTable、Collections的synchronizedCollection（）方法保证的集合。

4、线程兼容

线程兼容就是我们通常意义上所讲的一个类不是线程安全的。

线程兼容是指对象本身并不是线程安全的，但是可以通过在调用端正确地使用同步手段来保证对象在并发环境下可以安全地使用。Java API中大部分的类都是属于线程兼容的。如与前面的Vector和HashTable相对应的集合类ArrayList和HashMap等。

5、线程对立

线程对立是指无论调用端是否采取了同步错误，都无法在多线程环境中并发使用的代码。由于java语言天生就具有多线程特性，线程对立这种排斥多线程的代码是很少出现的。

一个线程对立的例子是Thread类的supend()和resume()方法。如果有两个线程同时持有一个线程对象，一个尝试去中断线程，另一个尝试去恢复线程，如果并发进行的话，无论调用时是否进行了同步，目标线程都有死锁风险。正因此如此，这两个方法已经被废弃啦。