您的位置:

java线程安全,java线程安全的类

本文目录一览:

Java中如何保证线程安全性

线程安全主要在体现在这三个方面:

1.原子性:提供互斥访问,同一时刻只能有一个线程对数据进行操作,(atomic,synchronized);

2.可见性:一个线程对主内存的修改可以及时地被其他线程看到,(synchronized,volatile);

3.有序性:一个线程观察其他线程中的指令执行顺序,由于指令重排序,该观察结果一般杂乱无序,(happens-before原则)。

所以想保证线性安全的话只要从这三个方面入手就可以了。

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

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

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

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

加锁

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

public class Synchronized{

private ListString  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.copyOf(elements, len + 1);

newElements[len] = e; // 赋值

setArray(newElements); // 设置内部的数组

return true;

} finally {

lock.unlock();

}

}

Collections.synchronizedList

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

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

static class SynchronizedListE

extends SynchronizedCollectionE

implements ListE {

private static final long serialVersionUID = -7754090372962971524L;

final ListE list;

SynchronizedList(ListE 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 SynchronizedCollectionE implements CollectionE, Serializable {

private static final long serialVersionUID = 3053995032091335093L;

final CollectionE c;  // Backing Collection

final Object mutex;     // Object on which to synchronize

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

 /**

* @serial include

*/

static class SynchronizedListE

extends SynchronizedCollectionE

implements ListE {

private static final long serialVersionUID = -7754090372962971524L;

final ListE list;

SynchronizedList(ListE list) {

super(list);

this.list = list;

}

SynchronizedList(ListE list, Object mutex) {

super(list, mutex);

this.list = list;

}

这里只是列举SynchronizedList ,其他类类似,可以看下源码了解下。

测试

public class Main {

public static void main(String[] args) {

ListString names = new LinkedList();

names.add("sub");

names.add("jobs");

// 同步方法1 内部使用lock

long a = System.currentTimeMillis();

ListString strings = new CopyOnWriteArrayList(names);

for (int i = 0; i 100000; i++) {

strings.add("param1");

}

long b = System.currentTimeMillis();

// 同步方法2 装饰器模式使用 synchronized

ListString 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中为什么说,String是线程安全的?

String是不可变类,所以是线程安全的。

1、所有不可变类都是线程安全的,线程安全的类不一定是不可变类,如StringBuffer是可变类,靠锁实现线程安全。

2、StringBuffer方法上都加了synchronized,StringBuilder没有,StringBuilder在多线程情况下是会出现问题,但是线程安全线程非安全指的是你业务环境需要线程安全考虑不考虑。多并发网络编程这块会考虑这些。

在Java语言中,线程是一种特殊的对象,它必须由Thread类或其子(孙)类来创建。

通常有两种方法来创建线程:

其一,使用型构为Thread(Runnable)的构造子将一个实现了Runnable接口的对象包装成一个线程。

其二,从Thread类派生出子类并重写run方法,使用该子类创建的对象即为线程。

值得注意的是Thread类已经实现了Runnable接口,因此,任何一个线程均有它的run方法,而run方法中包含了线程所要运行的代码。线程的活动由一组方法来控制。Java语言支持多个线程的同时执行,并提供多线程之间的同步机制(关键字为synchronized)。