java线程安全的list

1. java实际开发中set，Map，List分别用在什么情况

set、map、list是Java API封装的数据结构。之所以封装它们，是为了符合数学意义上的set、map和list上的一些特唯卖点。
比如set（集合）具有无序性，而且元素不能重复。
map主要是散列思想，即key-value值对。
list是链表结构，插入和删除元素，一个在头，一个在尾。
另外还有Stack是同一端插入和删除。
你说他们功能一样其实是错的，虽然对于某些问题用他们都可以解决，比如迷宫问题，可以用Stack，可以用链表，甚至可以直接用个简单的一维数组（因为多维数组可以由一维数组表示），但是解决时的复杂度是不同的。这其中除了算法中的时间、空腔老间代价的不同（比如使用散列，搜索时间大大减少，但是占用空间增大），当然还包括使用不同数据结构解决不同问题时的“自然”程度（即让别人容易明白你的算法的程度）。
说了这么多，其实封装这些东西就是为了方便编程，方便实现功能。
就像你可以说：“一条语句和一个函数（语句组成）本质上都是相同的，那为什么要那么麻烦设计函数？”那你就可以去查查函数编程思想和之后发展起来的面向对象指圆逗编程思想的优势。

最后再提下Java里面一些高级点的东西，即所谓线程安全，某些数据结构封装类不是线程安全的，而另外一些是，这些你可以去查看API或者底层代码实现，要花费很大耐心的

2. 怎样保证线程安全

如何确保Java线程安全？
java中，线程安全的解决方法或过程：

1.如果对象是immutable，则是线程安全的，例如:String，可以放心使用。

2. 如果对象是线程安全的，则放心使用。

3.有条件线程安全，对于Vector和Hashtable一般情况下是线程安全的，但是对于某些特殊情况，需要通过额外的synchronized保证线程安全。

4.使用synchronized关键字。
什么是线程安全，实现线程肆中备安全有哪些方法
自己学习的时候做了一些笔记,希望对你有帮助

当一个类已经很好的同步以保护它的数据时,这个类就称为“线程安全的”---我没有跑题...

5.线程的同步与死锁

1.什么是同步

通过synchronized关键字标识方法或者代码块,限制线程对其内容的操作(同步详细介绍参见 .)

2.为什么要同步

java允许多线程并发控制，当多个线程同时操作一个可共享的资源变量时（如数据的增删改查），

将会导致数据不准确，相互之间产生冲突，因此加入同步锁以避免在该线程没有完成操作之前，被其他线程的调用，

从而保证了该变量的唯一性和准确性.

3.进行同步的格式

同步代码块

synchronized (同步的线程对象){

需要同步的代码块;

}

同步方法

synchronized 其他访问修培拦饰符返回值方法名称(){

方法内容

}

(synchronized也可以修饰静态方法，此时如果调用该静态方法，将会锁住整个类)

4.什么是死锁

死锁是进程死锁的简称,是指多个进程循环等待它方占有的资源而无限期地僵持下去的局面。它是计算机操作系统乃至并发程序设计中最难处理的问题之一

死锁的解决

(死锁详细介绍参见进程死锁及解决办法.docx)

5.注意点

1.同步是一种高开销的操作，因此应该尽量减少同步的内容。

通常没有必要同步整个方法，使用synchronized代码块同步关键代码即可。
怎样保证线程安全，程序运行
只需要两个线程和一个数据缓存链。 线程1:图片采集线程，不停的采集数据，放到数据链里缓存
php如何保证线程安全
线程安全本身在php 的运行原理上就做到了,每个请求重新分配的内存空间,所谓php 的现线程安全,指的是 php扩展, 随着扩展模块的启动,分配的内存可以提供给多个请求调用.

php线程安全通过全局的global_id ,为每个全局变量做了唯一ID的区分.
java中 sevlert 如何线程安全如何保证?
首先先说BS是什么：

BS 指的是网站开发建设，程序员从无到有创建出一个程序，网站，或游戏，通常称之为开发。

JAVA中BS开发：

指的是用java进行网站开发。

通常，单位在招人时，都希望是招熟手，也就是所谓的有开发经验的程序员。

java中所谓的BS开发经验：

指的就是java开发程序员，有开发过网站项目的经验。

关于BS网站开发要求：

别的语言我不知道，但是java我还能说上一说，因为我本身就是这个行业的从业者。

首先，要会基础的HTML/CSS，起码你要看的懂做样式的同事给你的东西。

然后，Servlet,JSP,javaScript,这些要学好，当然，重中之重是java基础扎实，不然，你读不懂别人的逻辑，也无法按照单位给的需求实现出功能。

最后，就是对框架的运用熟练了，每个单位用的框架不同，我用的SpringMVC框架。
请教多线程数据库程序如何保证线程安全
你的提问就有问题

当你的程序不管是不是多线程的

获得到一个数据库连接是 数据库会把这个连接标记为繁忙 当其他程序访问时它会返回另外空闲的连接

连接个数是有限的 如果一直不释放连接 数据库就会告诉你连接已经使用完了

这里和线程安全有何关系呢？ 线程安全和数据库操作没有直接关系
除了synchronized和lock还有哪些保证线程安全的方法
1 每次查询少查点，用rowid记录标记位，下次查询从标记位开始。就是个变裂毁相的分页。

2 jdk1.5以后有了java.util.concurrent包。

wait/notify 是另外一种方式?我第一次听说。
spring singleton实例中的变量怎么保证线程安全
spring中管理的bean实例默认情况下是单例的[sigleton类型],就还有prototype类型

按其作用域来讲有sigleton,prototype,request,session,global session。

spring中的单例与设计模式里面的单例略有不同，设计模式的单例是在整个应用中只有一个实例，而spring中的单例是在一个IoC容器中就只有一个实例。

但spring中的单例也不会影响应用的并发访问，【不会出现各个线程之间的等待问题，或是死锁问题】因为大多数时候客户端都在访问我们应用中的业务对象，而这些业务对象并

没有做线程的并发限制，只是在这个时候我们不应该在业务对象中设置那些容易造成出错的成员变量，在并发访问时候这些成员变量将会是并发线程中的共享对象，那么这个时候

就会出现意外情况。

那么我们的Eic-server的所有的业务对象中的成员变量如，在Dao中的xxxDao,或controller中的xxxService，都会被多个线程共享，那么这些对象不会出现同步问题吗，比如会造

成数据库的插入，更新异常？

还有我们的实体bean，从客户端传递到后台的controller-->service-->Dao,这一个流程中，他们这些对象都是单例的，那么这些单例的对象在处理我们的传递到后台的实体bean不

会出问题吗？

答：[实体bean不是单例的]，并没有交给spring来管理，每次我们都手动的New出来的【如EMakeType et = new EMakeType();】，所以即使是那些处理我们提交数据的业务处理类

是被多线程共享的，但是他们处理的数据并不是共享的，数据时每一个线程都有自己的一份，所以在数据这个方面是不会出现线程同步方面的问题的。但是那些的在Dao中的

xxxDao,或controller中的xxxService，这些对象都是单例那么就会出现线程同步的问题。但是话又说回来了，这些对象虽然会被多个进程并发访问，可我们访问的是他们里面的方

法，这些类里面通常不会含有成员变量，那个Dao里面的ibatisDao是框架里面封装好的，已经被测试，不会出现线程同步问题了。所以出问题的地方就是我们自己系统里面的业务

对象，所以我们一定要注意这些业务对象里面千万不能要独立成员变量，否则会出错。

所以我们在应用中的业务对象如下例子；

controller中的成员变量List和paperService：

public class TestPaperController extends BaseController {

private static final int List = 0;

@Autowired

@Qualifier("papersService")

private TestPaperService papersService ;

public Page queryPaper(int pageSize, int page,TestPaper paper) throws EicException{

RowSelection localRowSelection = getRowSelection(pageSize, page);

List paperList = papersService.queryPaper(paper,localRowSelecti......>>
如何解决线程安全问题
有2种解决方法。

第一，是采用原子变量，毕竟线程安全问题最根本上是由于全局变量和静态变量引起的，只要保证了对于变量的写操作要么全写要么不写，就可以解决线程安全，定义变量用sig_atomic_t和volatile。

第二，就是实现线程间同步啦，用互斥索，信号量。让线程有序的访问变量就可以啦
spring mvc怎么保证线程安全
参考如下内容，讲的很好，可以配置controller为单例模式，每次都新建一个：

SpringMVC和Struts2中是并发访问否会存在线程安全问题。

对于使用过SpringMVC和Struts2的人来说，大家都知道SpringMVC是基于方法的拦截，而Struts2是基于类的拦截。

对于Struts2来说，因为每次处理一个请求，struts就会实例化一个对象；这样就不会有线程安全的问题了;

而Spring的controller默认是Singleton的，这意味着每一个request过来，系统都会用原有的instance去处理，这样导致两个结果：

一是我们不用每次创建Controller，二是减少了对象创建和垃圾收集的时间;由于只有一个Controller的instance，当多个线程调用它的时候，它里面的instance变量就不是线程安全的了，会发生窜数据的问题。

当然大多数情况下，我们根本不需要考虑线程安全的问题，比如,service等，除非在bean中声明了实例变量。因此，我们在使用spring mvc 的contrller时，应避免在controller中定义实例变量。

如：

[java] view plain print?

public class Controller extends AbstractmandController {

protected pany pany;

protected ModelAndView handle(HttpServletRequest request,HttpServletResponse response,Object mand,BindException errors) throws Exception {

pany = ................;

}

}

解决方案：

有几种解决方法：

1、在Controller中使用ThreadLocal变量

2、在spring配置文件Controller中声明 scope="prototype"，每次都创建新的controller

所在在使用spring开发web 时要注意，默认Controller、Dao、Service都是单例的。

3. java里线程安全是什么意思有什么作用

比如说，两个线程操作同一个ArrayList变量，那么一个线程这一时刻读的数据可能在下一刻要改变。

一般在类似于下面的情景下考虑线程安全的问题：

ArrayList procts=new ArrayList ();
procts用来存放生产出来的产品。
现在假设：有3个消费者线程，2个生产者线程。
每个生产者线程生产出一个产品，执行
procts.add(new Proct（）);
每个消费者线程消费一个产品执行
if(procts.size()>=1){ procts.remove(0);}

如果procts里现在只有一个产品可以消费，但是有2个消费者线程请求消费，那么就有可能出现一个产品被同时消费的问题，而这是和实际不符的。

但是不同的线程访问Vector的时候不会发生这种错误，因为java会有相应的机制是同一时刻只有一个线程对这个变量操作。

这就是所谓的：
Vector：是线程安全的
ArrayList：不是线程安全的

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