什么是JUC

-java.util.concurrent
-java.util.concurrent.atomic
-java.util.concurrent.locks
业务：普通的线程代码 Thread
Runable 没有返回值、效率相比Callable较低

2.线程和进程

进程：一个程序
一个进程往往可以包含多个线程，至少包含一个
Java默认有两个线程：mian 和 GC
线程：开了进程Typora，鞋子，自动保存等
对于java而言：Thread、Runnable、Callable

并发和并行

并发编程：

• 并发（多线程同时操作一个资源）
  -CPU，模拟出多条线程快速交替
• 并行（多个线程一起走）
  并发编程的本质：充分利用CPU的资源

真正的多线程开发，公司中的开发，降低耦合性，线程就是一个单独的资源类，没有任何附属操作 属性、方法

传统锁synchronized:本质：队列、锁

lock锁

ReentranLock：可重入锁（常用）
ReentranReadWriteLock.ReadLock：读锁
ReentranReadWriteLock.WriteLock：写锁

公平锁：new FairSync（）十分公平，可以先来后到
非公平锁：new NonFairSync（）十分不公平，可以插队（默认）

lock锁和Synchronized的区别

1.Synchronized 内置java关键字，lock是一个java类
2.Synchronized 无法判断获取锁的状态，lock是可以判断是否获得锁
3.Synchronized 会自动释放锁，lock必须手动释放
4.Synchronized 线程1（获得锁、阻塞）线程二（等待），lock就不一定会等待下去
5.Synchronized 可重入锁，不可以中断的 ，非公平，lock，可重入锁可以判断锁，可以自己设置。
6.Synchronized 适应少量的代码同步，lock适合大量的代码

锁是什么，如何判断锁的是谁

8锁现象
对象、Class

Condition

创建方式：Condition condition = lock.newCondition();

Condition中的await()对应Object的wait()；
Condition中的signal()对应Object的notify()；
Condition中的signalAll()对应Object的notifyAll()。
可以实现对应锁的等待和开始

集合不安全

list、set
java.util.ConcurrentModficationException 并发修改异常
1.List<String> list = new Vector<>()
2.List<String> list = Collections.synchronizedList(new ArrayList<>())
3.List<String> list = new CopOnWriteArrayList<>()

CopOnWrite 写入时复制 COW 计算机程序设计领域的一种优化策略
写入时避免覆盖，造成数据问题
CopOnWrite 对比 Vector：vector用的是synchronized锁 而CopOnWrite用的是lock锁

Map
1.Map<String,String> map = Collections.synchronizedMap(new HashMap<>())
2.Map<String,String> map = new ConcurrentHashMap<>()

Callable对比Runnable

1.可以有返回值
2.可以抛出异常.
3.方法不同 run\call

new Thread(new FutureTask(Callable)).start()
有缓存、可能有阻塞

常用的辅助类

1.CountDownLatch

private void psvm() {
        // TODO 自动生成的方法存根
        // 总数是6
        CountDownLatch cdl = new CountDownLatch(6);
        
        for (int i = 0; i <= 6; i++) {
            new Thread(() -> {
                cdl.countDown();// -1
            }).start();
        }
        try {
            cdl.await();//等待计数器归零再向下执行
        } catch (InterruptedException e) {
            // TODO 自动生成的 catch 块
            e.printStackTrace();
        }
        System.err.println("关门");
    }

原理：
-countDown();// -1
-await();//等待计数器归零再向下执行
-每次有线程调用countDown()数量-1，当计数器为0，调用await()就会被唤醒继续执行

2.CyclicBarrier

加法计数器

 public static void main(String[] args) {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(6,()->{
            System.out.println("数量达到6的时候调用");
        });
        for (int i = 1; i < 7; i++) {
            int a=i;
            new Thread(()->{
                try {
                    System.out.println(a);
                    cyclicBarrier.await();//+1
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }

    }

1.当声明的屏障和线程调用的await次数相等时,先执行我们预声明的线程,
然后再执行调用await方法线程的后续代码.
2.重新调用count方法时,结果和第一次执行一样,说明CyclicBarrier的await方法是可以重复使用的.
3.CyclicBarrier就像团队中的领导,parties声明的屏障就是领导管理的员工数,线程就是员工,线程调用await方法就像是员工开会时报道,等全部员工报完道,
CyclicBarrier开始开会,会议开完后,然后员工再继续接着回去工作.

3.Semaphore

信号量

 public static void main(String[] args) {
        //线程数量
        Semaphore semaphore = new Semaphore(3);
        for (int i = 0; i < 6; i++) {
            new Thread(()->{
                try {
                    //acquire()得到
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName()+"抢到车位");
                    TimeUnit.SECONDS.sleep(2);
                    System.out.println(Thread.currentThread().getName()+"离开车位");

                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    //.release()释放
                    semaphore.release();
                }
            },String.valueOf(i)).start();
        }


    }

作用：多个共享资源互斥的使用，并发限流，控制最大的线程数

读写锁 ReadWriteLock