多线程之线程安全
线程安全
线程是越多越好吗？答案否，线程太多的话，会造成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.循环等待条件 ——若干进程之间形成头尾相连的等待关系
常用解决方案： 锁加过期时间，或者抢锁失败释放已有锁标记
悲观锁和乐观锁
悲观锁和乐观锁的实现方式
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的值（“比较+更新”整体是一个原子操作），否则不会执行任何操作。一般情况下，“更新”是一个不断重试的操作。
腾讯云开发者
