Java集合中那些类是线程安全的

线程安全，即线程同步。
在多线程并发访问状况下，当前某一时刻，仅容许一个线程持有对象的锁，执行其代码。执行完毕后，释放锁，其余线程竞争得到该锁，再进行排他性的访问

简单地说，你看一个类里面每一个方法都加了synchronized修饰符，那它就是线程安全的。
既然类里面每个操做都加了线程同步操做，那么在外面就不用再写synchronized了。

好比Vector和ArrayList，两者惟一的区别就是Vector每一个方法都自带同步机制。
这样的话，好比我要往集合里面加一个元素，又要保证多个线程不会同时调用同一个对象的add()方法，ArrayList里面就要酱紫写：

ArrayList<String> list = new ArrayList<>();
synchronized (list) {
    list.add("233");
}

而Vector里面只要酱紫写就好了：

Vector<String> list = new Vector<>();
list.add("233");

为何？
由于ArrayList的add方法是酱紫定义的：

public boolean add(E object) {
     ...
}

而Vector的add方法是酱紫定义的：

public synchronized boolean add(E object) {
    .....
}

因此一样调用add()方法，对Vector对象再加synchronized就是画蛇添足

线程安全类

在集合框架中， 下面是这些线程安全的同步的类：

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

statck：堆栈类，先进后出

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

enumeration：枚举，至关于迭代器

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

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

其余：

1. hashtable跟hashmap的区别

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

不须要线程安全的场景，建议使用HashMap，由于效率高，须要线程安全的场景，建议使用ConcurrentHashMap；

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

用老的Vector/Hashtable类

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

public class StringBufferTest {
   private StringBuffer contents = new StringBuffer();
   public void log(String message){
      contents.append(System.currentTimeMillis());
      contents.append("; ");
      contents.append(Thread.currentThread().getName());
      for(int i=0;i<10000;i++){
        contents.append(i);   
          contents.append(message);    //append自己是线程安全的，修改contents时，其它线程没法访问。
          contents.append("\n");
      }
      contents.append("\n\n");
   }
   public void getContents(){
      System.out.println(contents);
   }
}

class RunThread extends Thread{
   String message;
   StringBufferTest buffer;
   public RunThread(StringBufferTest buffer, String message){
      this.buffer = buffer;
      this.message = message;
   }
   public void run(){
      while(true){
         buffer.log(message);
         buffer.getContents();
      }
   }
   public static void main(String[] args) {
      StringBufferTest ss = new StringBufferTest();
      new RunThread(ss, "you").start();
      new RunThread(ss, "me").start();
      new RunThread(ss, "she").start();
   }
}
        StringBuilder和StringBuffer的方法是如出一辙，就是一个多线程和一个单线程的问题。线程调用同一StringBuffer 的append方法，这跟他是否是线程安全没有关系的，除非你的结果是append的一系列字符串变乱了，那才能说明他是线程不安全的。线程安全是指任什么时候刻都只有一个线程访问临界资源。线程安全 并非说他的一系列操做是同步的 只是对于他执行某个方法的时候不容许别的线程去改变。针对一个类来讲是否是线程安全就要看，多个线程在同时在运行，这些线程可能会同时执行某个方法。可是每次运行结果和单线程执行的结果同样，那么就能够说是线程安全的。由于log方法没有上锁，每一个如今在append锁释放后，均可能获得cpu的执行片断。

但不要对多线程安全存在误解：

   public String toString(){
      StringBuffer buffer = new StringBuffer();
      buffer.append('<');
      buffer.append(this.name);
      buffer.append('>');
      return buffer.toString();
   }

       这个代码是彻底线程安全的，在方法内部定义的变量，在每一个线程线程进入的时候都会建立这个局部变量！不涉及线程安全问题。一般涉及系统安全的变量通常都是成员变量! stringBuffer自己的内部实现是现场安全的！线程安全那是类自己提供的功能是安全的。即你提供插入一个字符串，那么这个字符串插入是安全的，可是要插入两个字符串，两个的顺序你来定，这之间若是有别的插入出错就无论类的事情了，是你本身代码的问题。