javalist线程安全

Ⅰ java 线程安全是什么说说概念就行了

线程安全是指要控制多个线程对某个资源的有序访问或修改，而在这些线程之间没有产生冲突。
在Java里，线程安全一般体现在两个方面：

1、多个thread对同一个java实例的访问（read和modify）不会相互干扰，它主要体现在关键字synchronized。如ArrayList和Vector，HashMap和Hashtable（后者每个方法前都有synchronized关键字）。如果你在interator一个List对象时，其它线程remove一个element，问题就出现了。

2、每个线程都有自己的字段，而不会在多个线程之间共享。它主要体现在java.lang.ThreadLocal类，而没有Java关键字支持，如像static、transient那样。

Ⅱ java 如何实现一个线程安全的队列

以下是两个线程：

import java.util.*;

public class Thread_List_Operation {
//假设有这么一个队列
static List list = new LinkedList();

public static void main(String[] args) {
Thread t;
t = new Thread(new T1());
t.start();
t = new Thread(new T2());
t.start();

}

}

//线程T1,用来给list添加新元素
class T1 implements Runnable{

void getElemt(Object o){
Thread_List_Operation.list.add(o);
System.out.println(Thread.currentThread().getName() + "为队列添加了一个元素");
}
@Override
public void run() {
for (int i = 0; i < 10; i++) {
getElemt(new Integer(1));
}

}

}

//线程T2,用来给list添加新元素
class T2 implements Runnable{

void getElemt(Object o){
Thread_List_Operation.list.add(o);
System.out.println(Thread.currentThread().getName() + "为队列添加了一个元素");
}
@Override
public void run() {
for (int i = 0; i < 10; i++) {
getElemt(new Integer(1));
}

}

}

//结果（乱序）
Thread-0为队列添加了一个元素
Thread-1为队列添加了一个元素
Thread-0为队列添加了一个元素
Thread-1为队列添加了一个元素
Thread-1为队列添加了一个元素
Thread-1为队列添加了一个元素
Thread-1为队列添加了一个元素
Thread-1为队列添加了一个元素
Thread-1为队列添加了一个元素
Thread-1为队列添加了一个元素
Thread-1为队列添加了一个元素
Thread-1为队列添加了一个元素
Thread-0为队列添加了一个元素
Thread-0为队列添加了一个元素
Thread-0为队列添加了一个元素
Thread-0为队列添加了一个元素
Thread-0为队列添加了一个元素
Thread-0为队列添加了一个元素
Thread-0为队列添加了一个元素
Thread-0为队列添加了一个元素

Ⅲ java list是不是线程安全的

直接用Vector就可以了，它是线程安全的。ArrayList list=new ArrayList();就需要锁了，涉及同步，可以参考网上买票例子做。

Ⅳ 在java中什么是线程安全的

ArrayList和HashMap是异步的，
Vector和HashTable是同步的

List本身是一个接口，有一个类叫Vector，它实现了List，并且这个Vector是线程同步的。 在实际运用中，至少我没看见谁直接用List来装东西，最多会是这样:
List list = new ArrayList();
List list = new Vector();

Ⅳ Java中StringBuffer 、ArrayList是线程安全的吗

ArrayList不是线程安全的
你看API如果他们的方法定义里面有synchronized证明是线程安全的
StringBuffer是线程安全的

Ⅵ 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的集合工具类在添加方面更加快一些，其他方法这里篇幅关系就不测试了，大家有兴趣去试一下。

Ⅶ 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到一半，它也会让位于其它在此基础上操作的线程：