多线程并发拓展

死锁

死锁是指两个或两个以上的进程，因争夺资源而造成一种互相等待的作用，如果没有外力作用它们都将无法推进下去，此时我们就称系统进入死锁状态

死锁必要条件

互斥条件：进程对所分配的资源进行排他性的使用，在一段时间内某资源只有一个资源占用，如果此时还有其它进程请求资源，那么请求者只能等待

请求和保持条件：进程已经保持了至少一个资源，但又提出了新的资源请求，而该资源已被其它资源占用，此时请求进程阻塞，但又对自己已获得的其它资源保持不放

不剥夺条件：进程已获得的资源在未使用完之前不能被剥夺，只有在使用完之前被自己释放

环路等待条件：发生死锁时，一定存在一个进程环形的链条

死锁实例

/**
 * 死锁实例
 * 当flag=1是，先锁定了object1,并休眠了1000毫秒
 * 而example1睡眠的时候，另一个线程example2启动，先锁定object2，然后休眠了1000毫秒
 * example1休眠结束后需要锁定object2才能继续执行，而此时obejct2已被example2锁定
 * example2休眠结束后需要锁定object1才能继续执行，而此时object1已被example1锁定
 * example1、example2相互等待，都需要等待对方被锁定的对象先被释放才能继续执行，从而导致死锁
 */
@Slf4j
public class DeadLockExample1 implements Runnable{
    private int flag=1;
    //静态对象被类的所有对象共享的
    private static Object object1=new Object(),object2=new Object();

    @SneakyThrows
    @Override
    public void run() {
        log.info("flag:{}",flag);
        if(flag==1){
            synchronized (object1){
                Thread.sleep(1000);
                synchronized (object2){
                    System.out.println("1");
                }
            }
        }
        if(flag==0){
            synchronized (object2){
                Thread.sleep(1000);
                synchronized (object1){
                    System.out.println("0");
                }
            }
        }
    }

    public static void main(String[] args) {
        DeadLockExample1 example1=new DeadLockExample1();
        DeadLockExample1 example2=new DeadLockExample1();
        example1.flag=1;
        example2.flag=2;
        //example1,example2都处于可执行状态，但JVM线程调度先执行哪个线程是不确定的
        //example2的run可能在example1的run之前执行
        new Thread(example1).start();
        new Thread(example2).start();
    }
}

并发最佳实践

使用本地变量

使用不可变类

最小化锁的作用域范围：S=1/（1-a+a/n）

使用线程池的Executor,而不是直接new Thread执行

宁可使用同步也不要使用线程的wait和nofity方法

使用BlockingQueue实现生产-消费模式

使用并发集合而不是使用加了锁的同步集合

使用Semaphore创建有界的访问

宁可使用同步代码块，也不要使用同步的方法，使用同步代码块只会锁定一个对象而不是锁定一个方法

避免使用静态变量，如果必须使用，优先使用final变量

Spring与线程安全

String bean：singleton、prototype

无状态对象-每个单例的无状态对象都是线程安全的

HashMap和ConcurrentHashMap解析

Hashmap是一个数组结构，其中的每一项是一个链表，新建一个HashMap就会初始化一个数组，HashMap有两个参数影响它的性能，分别是初始容量和加载因子

初始容量是这里默认加载的值，默认值是16，容量是哈希表的桶的数量，初始容量是哈希表中创建的容量

加载因子默认值是0.75，加载因子是哈希表中在他的容量增加之前可以达到多满的一个尺度，当哈希表中的条目数量超过了加载因子与我们的容量的乘积，比如默认的是16*0.75，他将会调用里面的resize方法进行扩容，将它的容量进行翻倍，加载因子和初始容量在初始化的时候可以指定

HashMap的寻址方式

新插入的数据或是我们需要查询的数据，HashMap需要将他的key按照一定的计算规则计算出来的Hash值并对我们的数组长度进行取模结果呢作为它插入到数组中的index，在计算机中取模的代价远远高于未操作的代价，因此hashMap要求数组的长度必须为2的n次方，此时他将key的hash值对2的n-1次方进行与运算他的结果与我们的取模运算是相同的，HashMap并不要求我们用户传入初始容量时必须传入2的n次方总数，而是在初始化时传入的容量值计算出一个满足2的n次方的容量，HashMap是非线程安全的，而HashMap的非线程安全主要体现在resize方法时可能会出现死循环，HashMap在并发操作时可能会出现死循环

ConcurrentHashMap

底层数据结构依然是数组和链表，与HashMap不同的是ConcurrentHashMap它的最外层不是一个大的数组，而是一个egment数组，每个Segment数组包含一个与HashMap差不多的链表数组，在我们读写某个key的时候，先取出该key的hash值，并将hash值对我们的segment取模，从而得到该key，属于哪个segment，从而操作哪个segment，Segment继承自J.U.C下的ReentrantLock,所以我们可以很方便的对每个segment进行加锁，基于分段锁来进行处理的

不同点

HashMap：非线程安全，hashmap允许key和value为null

ConcurrentHashMap:线程安全，不允许key和value为null，java8废弃了分段锁的方案，使用了一个大的数组，当链表长度超过一定值，默认为8，把链表转换为红黑树，寻址复杂度从On，转换为Ologn