JUC并发
lock 线程交互: 通过 Condition 实现
final Lock lock = new ReentrantLock();
final Condition condition = new Condition();
try {
lock.lock();
condition.await();
condition.signal(); // --> 随机唤醒 signalAll 对应 notifyAll
} finally {
lock.unlock();
}
Condition 实现精准通知唤醒：
// 通过实现多个监视器，来实现精准唤醒（则可实现按顺序执行）
Condition condition1 = lock.newCondition();
Condition condition2 = lock.newCondition();
Condition condition3 = lock.newCondition();
public void fun1(){
condition1.await(); condition2.signal();
}
public void fun2(){
condition2.await(); condition3.signal();
}
public void fun3(){
condition3.await(); condition1.signal();
}
如何判断锁是谁？
public synchronized fun1(){...} // 锁调用者（对象）
public static synchronized fun1(){...} // 锁Class模板(全局唯一)
synchronized (obj) {} // 锁传进来的obj对象
java.util.ConcurrentModificationException 并发修改异常
List 并发-线程安全 解决方案:
Vector 默认加了synchronized -> jdk 1.0 出来的 | ArrayList -> jdk 1.2 出来的
Collection.synchronizedList(new ArrayList())
new CopyOnWriteArrayList --> JUC 底层 transient volatile
CopyOnWrite 写入时复制，是一种优化策略
MyCat 读写分离思想
为什么使用CopyOnWriteArrayList 而不使用Vector ？
Vector 默认使用了synchronized ，效率会比较低 (公平锁)
CopyOnWriteArrayList 使用的是lock锁，效率高 (非公平锁)
Set 并发-线程安全 解决方案:( HashSet 底层其实就是 HashMap)
Collection.synchronizedSet(new Set())
CopyOnWriteArraySet()
HashMap 并发-线程安全 解决方案:
HashMap 重点关键字 ： 初始化容量 initialCapacity 和 负载因子 loadFactory
ConcurrentHashMap --> 解决并发
Callable 创建线程的第三种方式(Thread , Runnable)
Runnable 不会返回结果，不会抛出异常
Callable 有返回值，可以抛出异常
new Thread(new Runnable()).start(); // -> Runnable可以代理Thread调用
// 但 Callable 无法直接代理使用Thread
// 这个时候 FutureTask（Callable） -> RunnableFuture -> Runnable
new Thread(new FutureTask(Callable)).start();
// Thread 和 Runnable 重写run方法，而Callable重写call方法
// FutureTask() 有返回值，future.get() 获取结果时，可能会有阻塞（因为需要等待响应）
辅助类：
CountDownLatch(int count) 减法计数器
countDownLatch.countDown(); 数量-1
countDownLatch.await(); 等待计数器归0，然后在向下执行程序
CyclicBarrier(int count , Runnable) 加法计数器
cyclicBarrier.await() 当线程数增加到指定树，就会执行Runnable方法
Semaphore(int count) 信号量 （抢车位，多个共享资源互斥使用，并发限流）
release() 释放信号量，并通知唤醒等待的线程
ReadWriteLock 读写锁：
readLock() 读锁（共享锁，多个线程可以同时使用）
writeLock() 写锁（独占锁，资源一次只能一个线程使用）
..... 还有一些知识，需后续学习
JMM
Volatile 是java虚拟机提供的轻量级的同步机制
保证可见性
不保证原子性
禁止指令重排
什么是JMM：
jmm 是java内存模型，一种概念和约定。
JMM同步约定：
线程加锁前，必须读取主存（主内存）中共享变量的最新值到 线程的工作内存中
线程解锁前，必须将共享变量的值 立刻 写回到主存中
加锁 和 解锁 是同一把锁
内存交互的8中操作：
lock（锁定）：作用于主内存的变量，把一个变量标识为一条线程独占状态。
unlock（解锁）：作用于主内存变量，把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定。
read（读取）：作用于主内存变量，把一个变量值从主内存传输到线程的工作内存中，以便随后的load动作使用
load（载入）：作用于工作内存的变量，它把read操作从主内存中得到的变量值放入工作内存的变量副本中。
use（使用）：作用于工作内存的变量，把工作内存中的一个变量值传递给执行引擎，每当虚拟机遇到一个需要使用变量的值的字节码指令时将会执行这个操作。
assign（赋值）：作用于工作内存的变量，它把一个从执行引擎接收到的值赋值给工作内存的变量，每当虚拟机遇到一个给变量赋值的字节码指令时执行这个操作。
store（存储）：作用于工作内存的变量，把工作内存中的一个变量的值传送到主内存中，以便随后的write的操作。
write（写入）：作用于主内存的变量，它把store操作从工作内存中一个变量的值传送到主内存的变量中。
Java内存模型还规定了在执行上述八种基本操作时，必须满足如下规则：
如果要把一个变量从主内存中复制到工作内存，就需要按顺寻地执行read和load操作， 如果把变量从工作内存中同步回主内存中，就要按顺序地执行store和write操作。但Java内存模型只要求上述操作必须按顺序执行，而没有保证必须是连续执行。
不允许read和load、store和write操作之一单独出现
不允许一个线程丢弃它的最近assign的操作，即变量在工作内存中改变了之后必须同步到主内存中。
不允许一个线程无原因地（没有发生过任何assign操作）把数据从工作内存同步回主内存中。
一个新的变量只能在主内存中诞生，不允许在工作内存中直接使用一个未被初始化（load或assign）的变量。即就是对一个变量实施use和store操作之前，必须先执行过了assign和load操作。
一个变量在同一时刻只允许一条线程对其进行lock操作，但lock操作可以被同一条线程重复执行多次，多次执行lock后，只有执行相同次数的unlock操作，变量才会被解锁。lock和unlock必须成对出现
如果对一个变量执行lock操作，将会清空工作内存中此变量的值，在执行引擎使用这个变量前需要重新执行load或assign操作初始化变量的值
如果一个变量事先没有被lock操作锁定，则不允许对它执行unlock操作；也不允许去unlock一个被其他线程锁定的变量。
对一个变量执行unlock操作之前，必须先把此变量同步到主内存中（执行store和write操作）
四大函数式接口
lambda 表达式 ；链式编程；函数式接口；Stream 流式计算
/**
* 题目要求：用一行代码实现:现有5个用户
* 1. ID必须是偶数
* 2. 年龄必须大于23
* 3. 用户名转为大写字母
* 4. 用户名倒叙
* 5. 只输出一个用户
*/
Author author1 = new Author(1,"a",21);
Author author2 = new Author(2,"b",22);
Author author3 = new Author(3,"c",23);
Author author4 = new Author(4,"d",24);
Author author5 = new Author(5,"e",25);
Author author6 = new Author(6,"e",26);
List<Author> list = Arrays.asList(author1, author2, author3, author4, author5, author6);
list.stream().filter(u->{return u.getId()%2 == 0 && u.getAge() > 23;})
.map(u->{return u.getName().toUpperCase();})
.sorted((u1,u2)->{return u2.compareTo(u1);})
.limit(1).forEach(System.out::println);
Forkjoin
jdk1.7出现的，用于处理大数据，将一个大任务分成若干个小任务进行处理，最后将结果进行汇总
特点：工作窃取（自己的任务完成后，会把没完成的任务拿过来处理），维护的是双端队列
// 使用Stream 并行执行，效率非常高
LongStream.rangeClosed(0L,10_0000_0000L).parallel().reduce(0,Long::sum);
浙公网安备 33010602011771号