使用了并发工具类库，线程就安全了吗
并发工具类库
- 有时会听到有关线程安全和并发工具的一些片面的观点和结论，比如“把 HashMap 改为 ConcurrentHashMap ，要不我们试试无锁的 CopyOnWriteArrayList 吧，性能更好，事实上，这些说法都特殊场景下都不太准确
- 为了方便开发者进行多线程编程，现代编程语言提供了各种并发工具类 并且提供了 JUC 包 java.util.concurrent , 但是没有充分了解他们的使用场景、解决的问题，以及最佳实践的话，盲目使用就可能导致一些坑、小则损失性能，大则无法保证多线程去看下业务逻辑正确性。
1. 没有意识到线程重用导致用户信息错乱的 Bug
ThreadLocal提高一个线程的局部变量，访问某个线程拥有自己局部变量。我们常常使用使用ThreadLocal 用来存储用户信息，但是发现ThreadLocal 有时获取到的用户信息是别人的，
我们知道，ThreadLocal适用于变量在线程间隔离，而在方法或类间共享的场景。如果用户信息的获取比较昂贵（比如从数据库查询用户信息），那么在 ThreadLocal中缓存数据是比较合适的做法。但，这么做为什么会出现用户信息错乱的 Bug ?
案例 ：
private ThreadLocal<Integer> currentUser = ThreadLocal.withInitial(() -> null);
@ApiOperation(value = "test2")
@GetMapping("/test2")
public ResponseMessage test2(@ApiParam(value = "id")@RequestParam(required = false) Integer id) {
//设置用户信息之前先查询一次ThreadLocal中的用户信息
String before = Thread.currentThread().getName() + ":" + currentUser.get();
currentUser.set(id);
String after = Thread.currentThread().getName() + ":" + currentUser.get();
//汇总输出两次查询结果
Map result = new HashMap();
result.put("before", before);
result.put("after", after);
return ResultBody.success(result);
在设置用户信息之前第一次获取的值始终应该是 null，但我们要意识到，程序运行在 Tomcat 中，执行程序的线程是 Tomcat 的工作线程，而 Tomcat 的工作线程是基于线程池的。
顾名思义，线程池会重用固定的几个线程，一旦线程重用，那么很可能首次从 ThreadLocal 获取的值是之前其他用户的请求遗留的值。这时，ThreadLocal 中的用户信息就是其他用户的信息。所以上图中我新用户 获取到了 旧用户遗留的 信息，
因为线程的创建比较昂贵，所以web服务器往往会使用线程池来处理请求，就意味着线程会被重用。这是，使用类似ThreadLocal工具来存放一些数据时，需要特别注意在代码运行完后，显式的去清空设置的睡觉。如果在代码中使用来自定义线程池，也同样会遇到这样的问题
优化
@ApiOperation(value = "test2")
@GetMapping("/test2")
public ResponseMessage test2(@ApiParam(value = "id")@RequestParam(required = false) Integer id) {
//设置用户信息之前先查询一次ThreadLocal中的用户信息
String before = Thread.currentThread().getName() + ":" + currentUser.get();
currentUser.set(id);
Map result = new HashMap();
try {
String after = Thread.currentThread().getName() + ":" + currentUser.get();
//汇总输出两次查询结果
result.put("before", before);
result.put("after", after);
}finally {
//在finally代码块中删除ThreadLocal中的数据，确保数据不串
currentUser.remove();
}
return ResultBody.success(result);
}1. 使用了线程安全的并发工具，并不代表解决了所有的线程安全问题
JDK 1.5 后推出的 ConcurrentHashMap，是一个高性能的线程安全的哈希表容器。“线程安全”这四个字特别容易让人误解，因为 ConcurrentHashMap 只能保证提供的原子性读写操作是线程安全的。
案例
public class Test {
private ConcurrentHashMap<String, Integer> map=new ConcurrentHashMap<String, Integer>();
public static void main(String[] args) {
final Test t=new Test();
for (int i = 0; i < 10000; i++) {
new Thread(new Runnable() {
@Override
public void run() {
t.add("key");
}
}).start();
}
}
public void add(String key){
Integer value=map.get(key);
if(value==null)
map.put(key, 1);
else
map.put(key, value+1);
System.out.println(map.get(key));
}
}
解决：
public class Test {
private ConcurrentHashMap<String, Integer> map=new ConcurrentHashMap<String, Integer>();
public static void main(String[] args) {
final Test t=new Test();
for (int i = 0; i < 10000; i++) {
new Thread(new Runnable() {
@Override
public void run() {
t.add("key");
}
}).start();
}
}
public synchronized void add(String key){
Integer value=map.get(key);
if(value==null)
map.put(key, 1);
else
map.put(key, value+1);
System.out.println(map.get(key));
}
}如果只是调用put或者get方法，ConcurrentHashMap是线程安全的，但是如果调用了get后在调用map.put(key, value+1)之前有另外的线程去调用了put，然后你再去执行put，就有可能将结果覆盖掉，但这个其实也不能算ConcurrentHashMap线程不安全，ConcurrentHashMap内部操作是线程安全的，但是外部操作还是要靠自己来保证同步，即使在线程安全的情况下，也是可能违反原子操作规则。。。
3. 没有认清并发工具的使用场景，因而导致性能问题
除了 ConcurrentHashMap 这样通用的并发工具类之外，我们的工具包中还有些针对特殊场景实现的生面孔。一般来说，针对通用场景的通用解决方案，在所有场景下性能都还可以，属于“万金油”；而针对特殊场景的特殊实现，会有比通用解决方案更高的性能，但一定要在它针对的场景下使用，否则可能会产生性能问题甚至是 Bug。
CopyOnWrite 是一个时髦的技术，不管是 Linux 还是 Redis 都会用到。在 Java 中，
CopyOnWriteArrayList 虽然是一个线程安全的 ArrayList，但因为其实现方式是，每次
修改数据时都会复制一份数据出来，所以有明显的适用场景，即读多写少或者说希望无锁读的场景。
案例：
测试写的性能
public static void main(String[] args) {
CopyOnWriteArrayList<Integer> cowal = new CopyOnWriteArrayList<Integer>();
ArrayList<Integer> list = new ArrayList<Integer>();
int count = 500;
long time1 = System.currentTimeMillis();
while (System.currentTimeMillis() - time1 < count) {
cowal.add(1);
}
time1 = System.currentTimeMillis();
while (System.currentTimeMillis() - time1 < count) {
list.add(1);
}
System.out.println("CopyOnWriteArrayList在" + count + "毫秒时间内添加元素个数为： "
+ cowal.size());
System.out.println("ArrayList在" + count + "毫秒时间内添加元素个数为： "
+ list.size());
}
- 以 add 方法为例，每次 add 时，都会用 Arrays.copyOf 创建一个新数组，频繁 add 时内存的申请释放消耗会很大
读性能比较
public static void main(String[] args) throws InterruptedException {
// create object of CopyOnWriteArrayList
List<Integer> ArrLis = new ArrayList<>();
List<Integer> copyOnWriteArrayList = new CopyOnWriteArrayList<>();
System.gc();
for (int i = 0; i < 100000; i++) {
ArrLis.add(i);
}
for (int i = 0; i < 100000; i++) {
copyOnWriteArrayList.add(i);
}
Thread.sleep(500);
long startTime = System.currentTimeMillis(); //获取开始时间
// print CopyOnWriteArrayList
System.out.println("ArrayList: "
+ ArrLis);
// 2nd index in the arraylist
System.out.println(" index: "
+ ArrLis.get(5000));
long endTime = System.currentTimeMillis(); //获取结束时间
System.out.println(" ArrayList : 程序运行时间：" + (endTime - startTime) + "ms"); //输出程序运行时间
Thread.sleep(500);
long startTime2 = System.currentTimeMillis(); //获取开始时间
// print CopyOnWriteArrayList
System.out.println("copyOnWriteArrayList: "
+ copyOnWriteArrayList);
// 2nd index in the arraylist
System.out.println(" index: "
+ copyOnWriteArrayList.get(5000));
long endTime2 = System.currentTimeMillis(); //获取结束时间
System.out.println(" copyOnWriteArrayList : 程序运行时间：" + (endTime2 - startTime2) + "ms"); //输出程序运行时间
System.gc();
}
- 总结：虽然JDK 给我们提供了一些并发工具类，我们要想充分体现他的性能 还需要更加的去了解他的机制 ，不然可能就会成为项目中的累赘
个人博客地址：http://blog.yanxiaolong.cn/
