什么是线程安全的数据结构？
简单的说就是不同线程可以访问同一份数据时，它们对这份数据的访问是无序、随机的，是不可控的。比如说你的房间谁都可以进来，但是你不确定他们谁先来谁后来或者可能同时来。你想让整件事更有秩序的在你的掌控之中，至少不能同时进来，于是就给房间上一把锁，每次只给一个人钥匙，他出来还钥匙之后你再给下一个人。这种带锁或等价机制的数据结构，就是线程安全的。
什么时候需要使用线程安全的数据结构？什么时候不需要？
1.常量，不需要线程安全。因为常量不会被修改。大家读取到的值一直都是不变的。大家无所谓先后或同时使用。
2.方法的局部变量，不需要线程安全。因为局部变量运行在每个线程自己专属的栈空间里。每个线程自己用自己的。
3.类的成员变量，分情况，如果是单例模式，则它的成员变量就会被多线程访问，则需要线程安全，例如海神平台crash监控LJTSUploadManager.java 单例模式的 LJTSUploadManagerHolder.INSTANCE , 该类的集合成员变量就遇到过线程不安全的问题。否则一般不需要。
4.静态变量，需要线程安全。
线程不安全的数据结构
1.ArrayList：内部实现是一个数组，其封装了一些对数组的操作。数组是一段连续的内存空间，所以它添加删除元素有可能需要移动很多元素。注意每次扩容都是新申请一大块连续的内存空间。
使用场景：
1）快速随机访问元素，比如不按顺序的，一会儿get(1),一会儿get(18)的。随机添加删除元素则不适合它。
2）你需要一个不同步的基于索引的数据访问时，请尽量使用ArrayList。ArrayList很快，也很容易使用。但是要记得要给定一个合适的初始大小，尽可能的减少更改数组的大小。
它对应的线程安全的结构为Vector。
2.LinkedList：内部实现是一个双向链表，每个元素都有标记前后两个元素的指针。这样它不需要连续的内存空间，添加删除元素时不需要移动其他元素，只需要改变前后元素的指针即可。每次添加新元素只申请该元素的一个小空间。
使用场景：
1）你的应用不会随机访问数据。因为如果你需要LinkedList中的第n个元素的时候，你需要从第一个元素顺序数到第n个数据，然后读取数据。
2）你的应用更多的插入和删除元素，更少的读取数据。因为插入和删除元素不涉及重排数据，所以它要比ArrayList要快。
它对应的线程安全的结构为ConcurrentLinkedQueue
3.HashMap：内部实现也是基于一个数组，但是数组每个元素都是一个链表。根据hashCode直接定位到数组的一个元素，然后code值一样的则放到它链表的next。
使用场景：这个大家太熟悉了，就是key-value键值对，不细说了。
它对应的线程安全的结构为Hashtable，但是它的同步机制是用synchronized的，性能比较低，我们应该使用ConcurrentHashMap。它引入了一个分段锁，把整个map分为多个小map，每个小map共用同一把锁，而且它用的锁是ReentrantLock。详细了解原理：http://www.importnew.com/22007.html
4.LinkedHashMap：在HashMap的基础上另外加一个链表把元素排上序。
使用场景：在需要按访问顺序或者插入顺序排序的时候，可以用它。比如LRU算法。
它对应的线程安全的结构为ConcurrentLinkedHashMap，引入什么pom包可以使用到它。。。TODO
5.TreeMap：有序的Map，它是按key排序，默认是自然顺序，也可以自定义比较器。它的排序是通过红黑树实现的。
使用场景：需要排序的map。
它对应的线程安全的结构为ConcurrentSkipListMap，它内部是用跳跃表实现的，实际上在并发环境下的排序这件事上，跳跃表比平衡树效率要高。
6.HashBasedTable：二维map，本质上用HashMap<R, HashMap<C, V>>实现。
使用场景：当你用多个键做索引的时候，比如(x,y)这样一个坐标作为key，就可以用它。
它对应的线程安全的结构暂时没有，我正打算实现出来。
7.TreeBasedTable：基于TreeMap<R, TreeMap<C, V>>的实现。
8.ArrayTable：是一个需要在构建的时候就需要定下行列的表格。这种表格由二维数组实现，这样可以在密集数据的表格的场合，提高时间和空间的效率。
最近做的项目中遇到一个问题：明明用了ConcurrentHashMap，可是始终线程不安全，除去项目中的业务逻辑，简化后的代码如下：
public class Test {
public static void main(String[] args) throws InterruptedException {
for (int i = 0; i < 10; i++) {
System.out.println(test());
}
}
private static int test() throws InterruptedException {
ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<String, Integer>();
ExecutorService pool = Executors.newCachedThreadPool();
for (int i = 0; i < 4; i++) {
pool.execute(new MyTask(map));
}
pool.shutdown();
pool.awaitTermination(1, TimeUnit.DAYS);
return map.get(MyTask.KEY);
}
}
class MyTask implements Runnable {
public static final String KEY = "key";
private ConcurrentHashMap<String, Integer> map;
public MyTask(ConcurrentHashMap<String, Integer> map) {
this.map = map;
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
this.addup();
}
}
private void addup() {
if (!map.containsKey(KEY)) {
map.put(KEY, 1);
} else {
map.put(KEY, map.get(KEY) + 1);
}
}
}
测试代码跑了10次，每次都不是400。这就很让人疑惑了，难道ConcurrentHashMap的线程安全性失效了？
查了一些资料后发现，原来ConcurrentHashMap的线程安全指的是，它的每个方法单独调用（即原子操作）都是线程安全的，但是代码总体的互斥性并不受控制。以上面的代码为例，最后一行中的：
map.put(KEY, map.get(KEY) + 1);
实际上并不是原子操作，它包含了三步：
- map.get
- 加1
- map.put
其中第1和第3步，单独来说都是线程安全的，由ConcurrentHashMap保证。但是由于在上面的代码中，map本身是一个共享变量。当线程A执行map.get的时候，其它线程可能正在执行map.put，这样一来当线程A执行到map.put的时候，线程A的值就已经是脏数据了，然后脏数据覆盖了真值，导致线程不安全。
简单地说，ConcurrentHashMap的get方法获取到的是此时的真值，但它并不保证当你调用put方法的时候，当时获取到的值仍然是真值
为了使上面的代码变得线程安全，我引入了synchronized关键字来修饰目标方法，如下：
public class Test {
public static void main(String[] args) throws InterruptedException {
for (int i = 0; i < 10; i++) {
System.out.println(test());
}
}
private static int test() throws InterruptedException {
ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<String, Integer>();
ExecutorService pool = Executors.newCachedThreadPool();
for (int i = 0; i < 4; i++) {
pool.execute(new MyTask(map));
}
pool.shutdown();
pool.awaitTermination(1, TimeUnit.DAYS);
return map.get(MyTask.KEY);
}
}
class MyTask implements Runnable {
public static final String KEY = "key";
private ConcurrentHashMap<String, Integer> map;
public MyTask(ConcurrentHashMap<String, Integer> map) {
this.map = map;
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
this.addup();
}
}
private synchronized void addup() { // 用关键字synchronized修饰addup方法, 同步的是this
if (!map.containsKey(KEY)) {
map.put(KEY, 1);
} else {
map.put(KEY, map.get(KEY) + 1);
}
}
}
运行之后仍然是线程不安全的，难道synchronized也失效了？
查阅了synchronized的资料后，原来，不管synchronized是用来修饰非静态方法，还是修饰代码块，其本质都是锁定某一个对象。修饰方法时，锁上的是调用这个方法的对象，即this；修饰代码块时，锁上的是括号里的那个对象
在上面的代码中，很明显就是锁定的MyTask对象本身。但是由于在每一个线程中，MyTask对象都是独立的，这就导致实际上每个线程都对自己的MyTask进行锁定，而并不会干涉其它线程的MyTask对象。换言之，上锁压根没有意义
理解到这点之后，对上面的代码又做了一次修改：
public class Test {
public static void main(String[] args) throws InterruptedException {
for (int i = 0; i < 10; i++) {
System.out.println(test());
}
}
private static int test() throws InterruptedException {
ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<String, Integer>();
ExecutorService pool = Executors.newCachedThreadPool();
for (int i = 0; i < 4; i++) {
pool.execute(new MyTask(map));
}
pool.shutdown();
pool.awaitTermination(1, TimeUnit.DAYS);
return map.get(MyTask.KEY);
}
}
class MyTask implements Runnable {
public static final String KEY = "key";
private ConcurrentHashMap<String, Integer> map;
public MyTask(ConcurrentHashMap<String, Integer> map) {
this.map = map;
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
synchronized (map) { // 对共享对象map上锁
this.addup();
}
}
}
private void addup() {
if (!map.containsKey(KEY)) {
map.put(KEY, 1);
} else {
map.put(KEY, map.get(KEY) + 1);
}
}
}
此时在调用addup时直接锁定map，由于map是被所有线程共享的，因而达到了让所有线程互斥的目的，线程安全达成。
修改后，ConcurrentHashMap的作用就不大了，可以直接将代码中的map换成普通的HashMap，以减少由ConcurrentHashMap带来的锁开销
最后特别补充的是，synchronized关键字判断对象是否是它锁定的对象，本质上是通过 == 运算符来判断的。换句话说，上面的代码中，可以采用任何一个常量，或者每个线程都共享的变量，或者MyTask类的静态变量，来代替map。只要该变量与synchronized锁定的目标变量相同（==），就可以使synchronized生效。