1.创建多线程

2.synchronized线程同步机制

3.volatile关键字

Ø通俗地讲：volatile变量在每次被线程访问时，都强迫从主内存中重读该变量的值，而当该变量发生变化时， 又会强迫线程将最新的值刷新到主内存。这样任何时刻，不同的线程总能看到该变量的最新值

volatile 

1.对变量的写操作不依赖当前值。

2.该变量没有包含在具有其他变量的式子中

特别适合作为状态标识量

另一个使用场景就是 使用两次

4.线程的安全与不安全

5.java并发工具与连接池

juc CountDownLatch 倒计时锁

juc 之Semephore信号量

尝试获取许可 获取到了就执行 获取不到 直接放弃，上图就只能有三个线程执行。

juc之CyclicBarrier循环屏障

只解决一个问题，就是让所有线程同时执行。

使用场景；

用于多线程计算数据，最后合并计算结果的计算场景。

1.cpu评测软件。（所有线程同时开始）

2.零点零分双十一秒杀 （假设有20个奖品，设置20个线程去抽奖，在0点0分时必须同时跑，不能有先后顺序。）

3抢票软件。（在后车票开售时，就必须有300或500个线程同时跑进去抢票）

和countDownLatch区别：

countDownLatch：

1.计数器只能用一次。

2.实现一个或多个线程需要等待其他线程完成某项操作后，才能继续往下执行（描述的是一个或多个线程等待其他线程 关系）

CyclicBarrier ：

1计数器可以重置（循环使用）

2.多个线程之间相互等待，知道所有线程都满足条件之后，才能继续执行后续操作（描述的是各个线程内部相互等待的关系，所以他能处理更复杂业务场景）。

juc之ReentrantLock重入锁（不太推荐使用）

比如我们拿到文件锁之后 跳出去做其他事，在回来还可以获得这个文件锁，就是可重入锁。

提高性能 是想尽办法 不让线程进入内核的阻塞状态。

总结  ：

1.当只有少了竞争者时 synchronized （不会引发死锁，jvm 会自动解锁）是最佳选择

2.竞争者不少，但是线程增长的趋势是可以预估的这是推荐用ReentrantLock

juc 之Condition线程等待与唤醒

任何需要预先设置好顺序的线程都需要Condition的支持

juc之Callable&Future

JUC-Fork/Join（jdk7 用于并行执行的框架） 框架

Fork/Join 是将大任务 分拆为若干个小任务，最终汇总每个小任务的结果后得到大任务结果的框架。fork---分拆，  join---合并。 

采用的是 工作窃取算法（如下图）

假如需要做一个比较大的任务，可以把这个任务 分割个若干个互不依赖的小任务，为了减少线程间的竞争，把这些子任务分别放到不通的队列里，为每个队列创建一个单独的线程来执行队列里的任务，线程和队列一一对应，比如A线程处理A队列里的任务，但是有的线程会先把自己队列里的任务处理完，而其他线程队列里还有任务需要处理，于是先处理完的线程回去其他未完成的队列里窃取任务，而这时多个线程会访问同一队列，为了减少任务线程和被窃取任务的线程间的竞争，通常我们会使用双端队列，被窃取任务的线程永远从双端队列的头部拿任务执行，而窃取任务的线程永远从双端队列的尾巴获取任务。

优点；充分利用线程进行并行计算，并减少了线程见得竞争

缺点： 在某些情况下还是存在竞争（比如双端队列里只有一个任务时），更加消耗系统资源。

局现性

1任务只能用fork和join来作为同步机制，如果使用了其他同步机制 工作线程就不能执行其他任务了。

2.所拆分的任务 不应该执行io操作（如读和写数据文件）

3.任务不能抛出检查异常，必须通过必要代码处理

代码：

类必须继承RecursiveTask<>类

其中Recursive是递归的意思，就是把大任务不断拆分成小任务。

下面例子做相加运算（从1加到100），假设相加任务很耗时，所以将任务分解多线程相加

流程，首先拆分子任务，之后让子任务各自执行，最后同过join 的方式合并结果

JUC-BlockingQueue

线程安全，主要用于生产者和消费者模型

线程池

ThreadPoolExecutor

如果运行线程数小于corePoolSize，直接创建新线程处理任务，如果线程池中线程数量大于corePoolSize且小于maximumpoolSize则只有当workQueue满了的时候 才会创建线程到maximumpoolSize值，来处理任务

HashMap与ConcurrentHashMap解析

HashMap

底层结构是  数组+链表

HashMap 有两个参数影响性能是初始容量（16）和加载因子（0.75）

加载因子是能达到最大容量，如16*0.75=12 当放入12个元素后HashMap就需要扩容为原来的2倍

HashMap 的寻址方式：

对于一个新插入或需要读取的数据，HashMap需要将其key按照一定计算规则计算出hash值并对数组长度进行取模，结果作为在查找中的index

单线程下rehash

多线程下rehash  (扩容) 容易出现死循环

ConcurrentHashMap（jdk7,基于分段锁处理的）

ConcurrentHashMap 底层结构任然是数组和链表，与HashMap不同的是最外层不是一个大数组而是一个Segment 数组

与hashmap的不同点：

hashmap  线程不安全，如许key和value为空，不容许在遍历的时候修改

ConcurrentHashMap 线程安全 不如许key和value为空，如许遍历的时候修改，并且跟新对后面的遍历可见

java8下优化的ConcurrentHashMap  将底层数结构中的链表用了红黑树来提高并发性（默认并发数达到8时将链表变为红黑树）

juc之Atomic与CAS算法（乐观锁）

单例模式代码

/**
 * 双重同步锁单例模式
 * 限制程序  不让其发生指令重排（volatile  关键字可以限制不发生指令重排）
 */

public class SingletonExample5 {
    //首先定义私有的构造方法(只有构造函数私有，才能保证外面不能通过new的方式不断创建对象出来)
    public SingletonExample5() {
    }
    //1.memory=allocate  分配对象内存空间
    //2.ctorInstance()  初始化对象
    //3.Instance=memory  设置instance指向刚分配的内存

    //在多线程下  jvm和cpu 优化，发生了指令重排

    //1.memory=allocate  分配对象内存空间
    //3.Instance=memory  设置instance指向刚分配的内存
    //2.ctorInstance()  初始化对象

    //下面 代码重排后 在线程a 执行第3步  给设置instance指向刚分配的内存
    //但是 线程b 刚好执行到判断那步  就会直接返回instance对象，但是实际instance对象并没有初始化


    //使用volatile可以限制指令重排  所以就是线程安全的

    //单例对象 volatile+双重检测机制---》禁止指令重排
    private volatile static SingletonExample5 instance=null;
   //静态工厂模式（懒汉模式，就是第一次使用的时候创建）
    public static SingletonExample5 getInstance(){
        if(instance==null){//双重监测机制
            synchronized(SingletonExample5.class){//同步锁
                if (instance==null){
                    instance=new SingletonExample5();
                }
            }

        }
        return instance;
    }


}

@Slf4j
 @ThreadSafe
 @Recommend
 public class SingletonExample7 {
 
     public SingletonExample7() {
     }
 
     public static SingletonExample7 getInstance(){
        return Singleton..getInstance();
     }
 
     private enum  Singleton{
         ;
         private  SingletonExample7 singlenton;
         //jvm 保证只被调用一次
         Singleton(){
             singlenton=new SingletonExample7();
         }
         public SingletonExample7 getInstance(){
             return singlenton;
         }
     }
 }