JUC并发编程

一、相关包：

java.util.concurrent
java.util.concurrent.atomic
java.util.concurrent.locks
java.util.function

二、创建一个线程的方式：

Thread、Runable、Callable

详情资料：传送门.

三、进程与线程：

1、进程是一段正在执行的程序，是资源分配的基本单元，而线程是CPU调度的基本单元。
2、进程间相互独立进程，进程之间不能共享资源，一个进程至少有一个线程，同一进程的各线程共享整个进程的资源（寄存器、堆栈、上下文）。
3、线程的创建和切换开销比进程小

进程：进程是一段正在执行的程序，是资源分配的基本单元，可包含多个线程。进程间相互独立，进程之间不能共享资源，同一进程的各线程共享整个进程的资源（寄存器、堆栈、上下文）。如：QQ.exe
线程：线程是CPU调度的基本单元。
java默认有两个线程，main、GC

四、线程的并行、并发

并发编程的目的：充分利用CPU资源。
并行：CPU多核，多个线程同时执行；线程池
并发：多个线程操作同一个资源，cpu一核时可模拟出多线程，快速交替。

五、线程的状态

public enum State {
        //新建
        NEW,
        
        //运行
        RUNNABLE,

        //阻塞
        BLOCKED,

        //等待，一直等，等到天荒地老
        WAITING,

        //超时等待，过期不候
        TIMED_WAITING,

        //结束
        TERMINATED;
    }

六、waitsleep:

1.来源与不同类
wait:Object类
sleep:Thread类
2.释放锁上
wait 释放锁
sleep 睡着了 ，就不会释放锁
3.使用位置
sleep 可以在任何地方睡觉
wait 必须在同步代码块中
4.是否需要捕获异常
都需要抛异常

七、synchrionized锁:

public class Demo001 {
    public static void main(String[] args) throws InterruptedException {
        Ticket aa =  new Ticket();
        new Thread(()-> {for(int a =0;a<20;a--){aa.sell();}},"A").start();
        new Thread(()-> {for(int a =0;a<20;a--){aa.sell();}},"B").start();
        new Thread(()-> {for(int a =0;a<20;a--){aa.sell();}},"C").start();
    }
}

class  Ticket {
    private int num =50;
    public synchronized void sell() {
        if(num>0){
        num--;
        System.out.println(num);
    }}
}

八、LOCK:

public class Demo001 {
    public static void main(String[] args) throws InterruptedException {
        Ticket aa =  new Ticket();

        new Thread(()-> {for(int a =0;a<20;a--)aa.sell();},"A").start();
        new Thread(()-> {for(int a =0;a<20;a--)aa.sell();},"B").start();
        new Thread(()-> {for(int a =0;a<20;a--)aa.sell();},"C").start();

    }
}

class   Ticket {
    private int num =50;
    Lock lock = new ReentrantLock(false);
    public  void sell() {
        lock.lock();
        try {
            if(num>0){
            num--;
            System.out.println(num);
        }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

九、synchrionized与LOCK区别：

总述：lock比synchrionized更灵活，功能更丰富

• synchrionized是关键字，lock是Lock接口,常见实现类ReentrantLock等
• synchrionized自动释放锁，lock需要手动释放锁 (不释放死锁）
• synchrionized如果线程1阻塞,线程2会一直等待，lock可以不必一直等待 (tryLock())
• synchrionized是可重入锁，不可中断，非公平锁；lock是可重入锁，可中断（lockInterruptibly），默认为非公平锁，但可以改为公平锁 (初始化是加参数fair)
• synchrionized不可判断锁的状态，lock可以判断是否获得了锁

十、synchrionized的生产者与消费者的实现与虚假唤醒问题：

实现：wait(),notifyAll() 等待、业务、通知
问题：传统的生产者和消费者模式，wait(),notifyAll()的方式实现，但只适用与两个线程，如果存在两个以上的线程，会出现虚假唤醒的问题。
原因：notifyAll()会唤醒所有的线程，即使if（)条件不满足也不在等待。（都会尝试去获取锁并运行，即使if()中的条件不再成立，也不会再次处于等待状态）
解决方案：将if换为while,即使线程被虚假唤醒，也会再次判断条件是否成立，不成立则再次进入等待状态。

十一、Lock版的生产与消费者问题：

Lock:取代synchrionized
Condition:取代监听，通过await与signal取代synchrionized的wait与notifyAll，并且精准唤醒
ReadWriteLock：

class   Ticket {
    private int num =50;
    Lock lock = new ReentrantLock(false);
    Condition condition = lock.newCondition();
    public  void sell() throws InterruptedException {
        condition.await();
        condition.signalAll();

十二、Condition的精准唤醒通知

    Lock lock = new ReentrantLock(false);
    Condition condition1 = lock.newCondition();
    Condition condition2 = lock.newCondition();
    public  void sell() throws InterruptedException {
        while(num!=1){
            condition1.await();
        }
        num=2;
        condition2.signal();

十三、八锁现象：

锁是什么？锁的是什么东西？

8锁：就是关于锁的8个问题；
1.两个同步方法，一个对象，谁先？执行synchrionized加方法上，锁的是方法的调用者，两个方法用同一个锁，谁先拿到锁，谁先执行
2.两个同步方法，一个对象，在第二个方法内sleep5秒，谁先？执行synchrionized加方法上，锁的是方法的调用者，两个方法用同一个锁，谁先拿到锁，谁先执行
3.增加一个非同步普通方法，谁先执行？普通方法，不加锁，不受锁的影响
4.两个对象，锁的对象不同，相互不影响
5.两个静态方法，只有一个对象，锁类，谁先拿到谁先执行
6.两个静态方法，两个对象，锁类，谁先拿到谁先执行
7.一个静态方法，一个同步方法，一个对象，锁的对象不同，互不影响
8.一个静态方法，一个同步方法，两个对象，锁的对象不同，互不影响

总结：new 锁的是this 对象 ， static 锁的是Class模板

十四、集合不安全——ListArrayList

ArrayList多线程下不安全，会出现java.util.ConcurrentModificationException
解决方案：

• List list = new Vector<>(); //Vector加了Synchrionized
• List list = List list = Collections.synchronizedList(new ArrayList<>()); //使用Collentions工具类
• List list = new CopyonWriteArrayList(); //底层使用Arrays.copyOf+Lock锁实现

十五、集合不安全——setHashSet

HashSet多线程下也不安全，会出现java.util.ConcurrentModificationException
解决方案：

• Set set = Collections.synchronizedSet(new HashSet<>()); //
• Set set2 = new CopyonWriteArraySet();

题外话：HashSet是什么？其实就是一个Map的key，无法重复，无序

十六、集合不安全——map/HashMap

什么初始化容量、加载因子？
加载因子是哈希表在其容量自动增加之前可以达到多满的一种尺度。如果当哈希表中的条目数超
出了加载因子与当前容量的乘积时,则要对该哈希表进行rehash()操作,从而哈希表将具有大约
两倍的数

HashMap默认初始化容量为16，加载因子为0.75，此时最大容量12，大于12就会两倍扩容。
Map map = new HashMap();等同于
Map map = new HashMap(16, (float) 0.75);

HashMap多线程下也不安全，会出现java.util.ConcurrentModificationException
解决方案：

• Map map2 = Collections.synchronizedMap(new HashMap<>());
• Map map3 = new ConcurrentHashMap();

ConcurrentHashMap原理：分段锁 :传送门//todo.

十六+、Callable接口(很简单)：

与Runnable相比==
1.Callable可以有返回值，
2.可以抛出异常，
3.方法是call()方法。

Callable使用：
FutureTask 实现了 RunnableFuture ,RunnableFuture 继承 Runnable；
FutureTask 里面可以传Callable
Callable返回值：

public class CallableTest {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        AAA aa = new AAA();
        FutureTask stringFutureTask = new FutureTask<>(aa);
        new Thread(stringFutureTask).start();
        String s = stringFutureTask.get();
        System.out.println(s);
    }
}

class AAA implements Callable{
    @Override
    public String call(){
        return "必将 再次 伟大 ！";
    }
}

Callable缓存：

1.Callable结果会有缓存
2.返回值可能会阻塞，可添加异步来解决阻塞问题。

十七、线程常用的三个辅助类：

CountDownLatch:出完关门
一个减法计数器，通过线程调用countDown(); await()进行等待，归零时继续往后走。

        CountDownLatch  ss = new CountDownLatch(6);
        for (int i=0;i<6;i++){
            int finalI = i;
            new Thread(()->{
                System.out.println(finalI);
                ss.countDown();
            }).start();
        }
        ss.await();
        System.out.println("OVER");

CyclicBarrier：

Semaphore:

十八、ReadWriteLock：

读读：可共存（共享锁，读锁，读锁是为锁住写锁）
读写：不可共存
写写：不可共存（独占锁，写锁）

十九、阻塞队列BlockingQueue：

FIFO:
阻塞发生情况：

• 队列满了，存操作阻塞
• 队列空了，取操作阻塞，等待生产

二十、BlockingQueue的四组API：

• 阻塞——抛出异常： //add满后再add会报错，remove空后再remove会报错
  - 阻塞——返回值： //offer,offer满后再offer会返回false；poll完后在poll会返回null

- 阻塞——一直等待： //put,put满后再put会一直等待；take完后在take会一直等待

• 阻塞——超时等待： //会等一段时间，超时了会返回结果

二十一、SynchronousQueue同步队列：

只能存一个值==

二十一、线程池（重点）： 池化技术：

优化资源的使用（事先准备好一些资源，用的时候直接使用，不用现创建，销毁，创建与销毁很浪费资源）。线程池、数据库连接池、内存池、对象池
线程池的好处：

• 线程复用，降低资源消耗。
• 控制最大并发数，提高响应速度。
• 管理线程，方便管理。

线程池有三大方法、七大参数、四种拒绝方式。
Executors工具类、ThreadPoolExecutor：

三大方法：

    public static void main(String[] args) {
           ExecutorService executorService1 = Executors.newSingleThreadExecutor(); //单一线程
           ExecutorService executorService2 = Executors.newFixedThreadPool(5); //固定线程
           ExecutorService executorService3 = Executors.newCachedThreadPool(); //火力全开
           //new Thread(()->{}).start();
        try {
            for(int i=0;i<100;i++){
            //使用exexute调用线程执行
                executorService3.execute(()->{
                    System.out.println(Thread.currentThread().getName());
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
        //用完需要关闭线程池
            executorService3.shutdown();
        }
    }

七大参数：

阻塞队列数+核心线程数 不够时 启动备用线程

四种拒绝策略：

请求线程数>核心线程数——>放入阻塞队列
请求线程数>核心线程数+阻塞队列大小——>启用备用线程
请求线程数>最大线程数+阻塞队列大小——>触发拒绝策略

1. AbortPolicy会抛出异常
2. CallerRunsPolicy哪里来的回哪里，让原来的线程处理
3. DiscardPolicy丢弃线程，默默舍弃
4. DiscardOldestPolicy尝试与最早的请求竞争，不一定会成功

二十二、CPU密集型与IO密集型（线程池调优）：

线程可以有N个,但是并行的线程最大为cpu数
CPU密集型：即最大线程数==cpu数量

        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor
                (       2,
                        Runtime.getRuntime().availableProcessors(),
                        1,
                        TimeUnit.MINUTES,
                        new linkedBlockingQueue(3),
                        Executors.defaultThreadFactory(),
                        new ThreadPoolExecutor.DiscardPolicy());

IO密集型：大于程序中很消耗IO的线程数，一般是2倍。

二十三、四大函数式接口

jdk1.5传统程序员：泛型、枚举、单例、反射
jdk1.8新时代程序员：函数式接口、响应式（链式）编程、lambda表达式、Stream流式计算

函数式接口：只有一个方法的接口，上面有注解@FunctionalInterface标注。如：Runnable （JUF:优势：简化编程模型，在新型的架构中大量使用）

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

1.函数型接口Function：

函数型接口，有一个输入参数，一个输出参数，只要是函数式接口均可以用lambda表达式简化；

    public static void main(String[] args) {


        Function function = (a)->{return "abc";};
        System.out.println(function.apply("333"));
    }

2.断言型接口Predicate:

断言型接口,输入参数，输出boolean；

public static void main(String[] args) {



    Predicate predicate = (o)->{return false;};
    System.out.println(predicate.test("666"));
}

3.消费型接口Consumer:

消费型接口，只传入参数，不返回值；

    public static void main(String[] args) {

        Consumer consumer = (o)->{System.out.println(o);};
        consumer.accept("qwe");
    }

4.供给型接口Supplier:

供给型接口，不传参数，只返回值；

    public static void main(String[] args) {

        Supplier