Java高并发之从零到放弃

前言

本篇主要讲解如何去优化锁机制
或者克服多线程因为锁可导致性能下降的问题

ThreadLocal线程变量

有这样一个场景，前面是一大桶水，10个人去喝水，为了保证线程安全，我们要在杯子上加锁
导致大家轮着排队喝水，因为加了锁的杯子是同步的，只能有一个人拿着这个唯一的杯子喝水
这样子大家都喝完一杯水需要很长的时间
如果我们给每个人分发一个杯子呢?是不是每人喝到水的时间缩小到了十分之一

多线程并发也是一个道理
在每个Thread中都有自己的数据存放空间（ThreadLocalMap）
而ThreadLocal就是在当前线程的存放空间中存放数据
下面这个例子，在每个线程中存放一个arraylist，而不是大家去公用一个arraylist

public class ThreadLocalTest {     public static ThreadLocal threadLocal = new ThreadLocal();     public static ArrayList list = new ArrayList();     public static class Demo implements Runnable {         private int i;         public Demo(int i) {             this.i = i;         }         @Override         public void run() {             list.add(i);             threadLocal.set(list);             System.out.println(threadLocal.get());         }     }     public static void main(String[] args) throws InterruptedException {         ExecutorService es = Executors.newFixedThreadPool(5);         for (int j = 0; j < 200; j++) {             es.execute(new Demo(j));         }         Thread.sleep(3000);         System.out.println(list.size());         es.shutdown();     } }

在每个线程内部有一块存储区域叫做ThreadLocalMap
可以看到，ThreadLocal采用set，get存取值方式
只有线程完全关闭时，在ThreadLocalMap中的数据才会被GC回收

这时有一个值得考虑的问题
我们使用线程池来开发的时候，线程池中的线程并不会关闭，它只是处于空闲状态
也就是说，我们如果把过大的数据存储在当前线程的ThreadLocalMap中，线程不断的调用，被空闲...
最后会导致内存溢出
解决方法是当不需要这些数据时
使用ThreadLocal.remove()方法将变量给移除

CAS操作

还有一种脱离锁的机制，那就是CAS
CAS带着三个变量，分别是:
V更新变量：需要返回的变量
E预期值：原来的值
N新值，传进来的新变量

只有当预期值和新值相等时，才会把V=N，如果不相等，说明该操作会让数据无法同步
根据上面的解释，大概就能知道CAS其实也是在保护数据的同步性

当多个线程进行CAS操作时，可想只有一个线程能成功更新，之后其它线程的E和V会不地进行断比较
所以CAS的同步锁的实现是一样的

CAS操作的并发包在Atomic包中，atomic实现了很多类型
不管是AtomicInteger还是AtomicReference，都有相同点，请观察它们的源码：

private volatile V value; private static final long valueOffset;

以上是AtomicReferenc

private volatile int value; private static final long valueOffset;

以上是AtomicIntege

都有value，这是它们的当前实际值

valueOffset保存的是value的偏移量

下面给出一个简单的AtomicIntege例子：

public class AtomicTest {     public static AtomicInteger atomicInteger = new AtomicInteger();     //public static AtomicReference atomicReference = new AtomicReference();     public static class Demo implements Runnable{         @Override         public void run() {             for (int j=0;j<1000;j++){                 atomicInteger.incrementAndGet();        //当前值加1并且返回当前值             }         }     }     public static void main(String[] args) throws InterruptedException {         ExecutorService es = Executors.newFixedThreadPool(10);         for (int i =0;i<10;i++){             es.submit(new Demo());         }         Thread.sleep(5000);         System.out.println(atomicInteger);     } }

你试着执行一下，如果打印出10000说明线程安全

使用CAS操作比同步锁拥有更好的性能

我们来看下incrementAndGet()的源码：

public final int incrementAndGet() {         return unsafe.getAndAddInt(this, valueOffset, 1) + 1;     }

来看下getAndAddInt()源码：

public final int getAndAddInt(Object var1, long var2, int var4) {         int var5;         do {             var5 = this.getIntVolatile(var1, var2);         } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));         return var5;     }

这里有一个循环，再细看源码发现是native的，虽然看不到原生代码，但是可以看出它这里做了一个CAS操作，不断地进行多个变量的比较，只有预设值和新值相等时，才跳出循环
var5就是需要更新的变量，var1和var2是预设值和新值

死锁

讲了那么多无锁的操作，我们来看一下一个死锁的现象
两个线程互相占着对方想得到的锁，就会出现死锁状况

public class DeadLock extends Thread{     protected String suo;     public static String zuo = new String();     public static String you = new String();     public DeadLock(String suo){         this.suo=suo;     }     @Override     public void run(){         if (suo==zuo){             synchronized (zuo){                 System.out.println("拿到了左，正在拿右......");                 synchronized (you){                     System.out.println("拿到了右，成功了");                 }             }         }         if (suo==you){             synchronized (you){                 System.out.println("拿到了右，正在拿左......");                 synchronized (zuo){                     System.out.println("拿到了zuo，成功了");                 }             }         }     }     public static void main(String[] args) throws InterruptedException {         for (int i=0;i<10000;i++){             DeadLock t1 = new DeadLock(zuo);             DeadLock t2 = new DeadLock(you);             t1.start();t2.start();         }         Thread.sleep(50000);     } }

如图：

出现了两个线程的死锁现象，所以说去锁不仅能提升性能，也能防止死锁的产生。

本文地址https://segmentfault.com/a/1190000012218687