多线程之线程安全

线程安全

线程是越多越好吗？答案否，线程太多的话，会造成CPU频繁的切换反而会造成很多线程处于等待状态。除了浪费资源和效率之外，多线程带来的其他风险：安全、死锁等
比如下面程序：

public class CountAdd implements Callable {
    private Map<String, Integer> map;

    public Map<String, Integer> getMap() {
        return map;
    }

    public void setMap(Map<String, Integer> map) {
        this.map = map;
    }

    public CountAdd(Map<String, Integer> map) {
        this.map = map;
    }

    @Override
    public Integer call() throws Exception {
        Integer integer = map.getOrDefault("count",0);
        map.put("count", ++integer);
        return map.get("count");
    }
}

public class ThreadMain {
    public static void main(String[] args) throws Exception {

        Map<String, Integer> countMap = Maps.newHashMap();

        ExecutorService executorService = Executors.newFixedThreadPool(100);
        for (int i = 0; i < 10000; i++) {
            executorService.submit(new CountAdd(countMap));
        }
        System.out.println("map"+countMap);

    }
}

输出结果
map{count=9831}
期望输出结果
map{count=10000}

出现问题的原因是因为不恰当的执行时序而出现不一样的结果。
关键代码：

map.put("count", ++integer);

在每个线程取count的值之后，进行+1操作然后将结果重新赋值给count。这时就会出现多个线程值被覆盖的情况，比如，线程1 第一次count = 0；在进行+1操作之前，线程2已经完成了+1操作并将值赋给了count，这时count应该是1。而线程1中的count还是0。所以多线程如果存在共享资源，并且该资源是有状态的，必然会涉及到数据不一致的情况。

所以针对此问题的解决方式：
加锁

synchronized (map) {
            Integer integer = map.getOrDefault("count", 0);
            map.put("count", ++integer);
        }

为什么加synchronized就可以让线程变的安全，synchronized的实现

锁

什么是锁，锁是一种同步机制。synchronized是一种锁，JUC的Lock是一种锁，锁是在多线程中为了保障程序的安全性的一种同步机制。
多线程+锁=万无一失？多度的使用锁，锁的创建和销毁相应的开销越大。而且不正常的使用会导致死锁。

package com.wyh.spring.generate.task;

public class DeadLockTest {
    public static void main(String[] args) throws Exception {

        final Object a = new Object();
        final Object b = new Object();

        new Thread(() -> {
            synchronized (a) {
                sleep(2000L);
                synchronized (b) {
                    System.out.println("do someThing...");
                }
            }
        }).start();

        new Thread(() -> {
            synchronized (b) {
                sleep(2000L);
                synchronized (a) {
                    System.out.println("do someThing...");
                }
            }
        }).start();

    }

    public static void sleep(Long time) {
        try {
            Thread.sleep(time);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

上面的例子，线程T1获取到a的锁，线程T2获取到b的锁。T1等待T2释放b,T2等待T1释放a，这样就形成死锁。
形成死锁的四种必要条件：
1.互斥条件 ——一个资源每次只能被一个进程使用
2.不可剥夺条件 ——进程对已有资源未使用完，不可剥夺
3.请求与保持条件 ——一个进程为请求一个一个资源而阻塞，已有资源不释放
4.循环等待条件 ——若干进程之间形成头尾相连的等待关系

常用解决方案：锁加过期时间，或者抢锁失败释放已有锁标记

悲观锁和乐观锁

image.png

悲观锁和乐观锁的实现方式

public class Lock {

    // ------悲观锁---------
    public synchronized void test(){
        //do something
    }

    public void testLock(){
        ReentrantLock lock = new ReentrantLock();
        lock.lock();
        //do something
        lock.unlock();
    }

    //-------乐观锁----------
    public void testOptimism(){
        AtomicInteger atomicInteger = new AtomicInteger();
        atomicInteger.incrementAndGet();
    }
}

悲观锁显式的锁定资源后再去执行操作，乐观锁则是直接操作。乐观锁的主要是由CAS实现
CAS算法涉及到三个操作数：

需要读写的内存值 V。

进行比较的值 A。

要写入的新值 B。

当且仅当 V 的值等于 A 时，CAS通过原子方式用新值B来更新V的值（“比较+更新”整体是一个原子操作），否则不会执行任何操作。一般情况下，“更新”是一个不断重试的操作。

最后编辑于：2019.09.23 13:25:30