概念
-
进程 && 线程
-
线程状态
-
wait && sleep
-
并发 && 并行
-
java.util.concurrent在并发编程中使用的工具类
- java.util.concurrent
- java.util.concurrent.atomic
- java.util.concurrent.locks
-
多线程模板编程
- 高内聚低耦合
- 线程——操作——资源类
-
synchronized与Lock的区别
- 首先synchronized是java内置关键字，在jvm层面，Lock是个java类；
- synchronized无法判断是否获取锁的状态，Lock可以判断是否获取到锁；
- synchronized会自动释放锁(a 线程执行完同步代码会释放锁 ；b 线程执行过程中发生异常会释放锁)，Lock需在finally中手工释放锁（unlock()方法释放锁），否则容易造成线程死锁；
- 用synchronized关键字的两个线程1和线程2，如果当前线程1获得锁，线程2线程等待。如果线程1阻塞，线程2则会一直等待下去，而Lock锁就不一定会等待下去，如果尝试获取不到锁，线程可以不用一直等待就结束了；
- synchronized的锁可重入、不可中断、非公平，而Lock锁可重入、可判断、可公平（两者皆可）
- Lock锁适合大量同步的代码的同步问题，synchronized锁适合代码少量的同步问题。
- 只有一个方法的接口，称为函数式接口（默认自带该@FunctionalInterface注解）
- Lambda表达式：拷贝小括号，写死右箭头，落地大括号
- 多线程交互中，必须要防止多线程的虚假唤醒（生产者满足某个条件时，理应通知某一个线程去消费，却唤醒所有的线程消费而产生非正常结果）。解决：判断只能用while，不能用if
- Lock类替换synchronize关键字，Condition的signaAll方法替换Object的notifyAll方法
- Condition的精确通知顺序访问：利用一个标记位，signal方法实现具体通知某个线程
- ArrayList扩容默认为当前的一半，HashMap扩容为当前的一倍，默认容量是16（24），扩容即为32（25），默认加载因子为0.75
多线程8锁
class Phone{
public synchronized void print1(){
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("1");
}
public synchronized void print2(){
System.out.println("2");
}
public void hello(){
System.out.println("hello");
}
}
/**
* @description: 多线程8锁
* 1.标准访问，先输出1还是输出2？ answer：按顺序访问，1 2
* 2.1方法暂停1秒，先输出1还是输出2？ answer：方法同步，1方法暂停，2方法等待，1 2
* 3.新增普通hello方法，先输出1还是输出hello？ answer：hello方法不是同步方法，无需等待，hello 1
* 4.两部手机，先输出1还是输出2？ answer：对象不同，无需等待方法1，2 1
* 5.两个静态同步方法，同一部手机，先输出1还是输出2？ answer：静态方法锁当前资源类.class文件，需等待，1 2
* 6.两个静态同步方法，两部手机，先输出1还是输出2？ answer：两个静态同步方法，锁当前资源类，1 2
* 7.一个普通同步方法，一个静态同步方法，一部手机，先输出1还是输出2？ answer：静态同步方法，锁当前资源类，普通同步方法锁当前对象，锁的不同，2 1
* 8.一个普通同步方法，一个静态同步方法，两部手机，先输出1还是输出2？ answer：静态同步方法，锁当前资源类，普通同步方法锁当前对象，锁的不同，2 1
*
* @author XLJ
* @date 2020/10/19 19:24
*/
public class Lock8 {
public static void main(String[] args) throws InterruptedException {
Phone phone1 = new Phone();
Phone phone2 = new Phone();
new Thread(()->{
phone1.print1();
},"A").start();
// Thread.sleep(1000);
new Thread(()->{
// phone2.print2();
phone1.print2();
},"B").start();
}
}
Callable
获得多线程方式：传统的是继承thread类和实现runnable接口，
java5以后又有实现callable接口和java的线程池获得
Callable与Runnable接口区别：
- Runnable重写run方法，Callable重写call方法
- 泛型，Callable有返回参数类型
- 重写call方法抛出异常
Callable的实现：
- Thread类中没有Callable的构造方法，需要通过“中介”去实现
- FutureTask类实现了Runnable接口，同时有Callable的构造方法
- 通过FutureTask类实现
- FutureTask.get方法获得Callable的返回参数
- 同一个FutureTask对象在被多个线程调用时，只会被调用一次
集合类不安全
- 线程不安全错误：java.util.ConcurrentModificationException（异常并发修改异常）
List不安全
- 解决方案：
- new Vector
- Collections.synchronizedList(new ArrayList())
- 写时复制：CopyOnWriteArrayList
Set不安全
- Collections.synchronizedSet()
- CopyOnWriteArraySet
- HashSet底层数据结构是HashMap中的Key
Map不安全
- Collections.synchronizedMap()
- ConcurrentHashMap
辅助类
CountDownLatch减少计数
- CountDownLatch主要有两个方法，当一个或多个线程调用await方法时，这些线程会阻塞。
- 其它线程调用countDown方法会将计数器减1(调用countDown方法的线程不会阻塞)，
- 当计数器的值变为0时，因await方法阻塞的线程会被唤醒，继续执行。
CyclicBarrier循环栅栏
- 字面意思是可循环（Cyclic）使用的屏障（Barrier）。
- 它要做的事情是，让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续干活。
- 线程进入屏障通过CyclicBarrier的await()方法。
Semaphore信号灯
- 在信号量上我们定义两种操作：
- acquire（获取） 当一个线程调用acquire操作时，它要么通过成功获取信号量（信号量减1），要么一直等下去，直到有线程释放信号量，或超时。
- release（释放）实际上会将信号量的值加1，然后唤醒等待的线程。
- 信号量主要用于两个目的，一个是用于多个共享资源的互斥使用，另一个用于并发线程数的控制。
阻塞队列BlockQueue
- 栈：先进后出；队列：先进先出
- 当队列是空的，从队列中获取元素的操作将会被阻塞
- 当队列是满的，从队列中添加元素的操作将会被阻塞
- 试图从空的队列中获取元素的线程将会被阻塞，直到其他线程往空的队列插入新的元素
- 试图向已满的队列中添加新元素的线程将会被阻塞，直到其他线程从队列中移除一个或多个元素或者完全清空，使队列变得空闲起来并后续新增
核心种类
- ArrayBlockingQueue：由数组结构组成的有界阻塞队列。
- LinkedBlockingQueue：由链表结构组成的有界（但大小默认值为integer.MAX_VALUE）阻塞队列。
- SynchronousQueue：不存储元素的阻塞队列，也即单个元素的队列。
核心方法
线程池ThreadPool
特点：线程复用、控制最大并发数、管理线程。
- 降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的销耗。
- 提高响应速度。当任务到达时，任务可以不需要等待线程创建就能立即执行。
- 提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会销耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。
7大参数
- corePoolSize：线程池中的常驻核心线程数
- maximumPoolSize：线程池中能够容纳同时执行的最大线程数，此值必须大于等于1
- keepAliveTime：多余的空闲线程的存活时间当前池中线程数量超过corePoolSize时，当空闲时间达到keepAliveTime时，多余线程会被销毁直到只剩下corePoolSize个线程为止
- unit：keepAliveTime的单位
- workQueue：任务队列，被提交但尚未被执行的任务
- threadFactory：表示生成线程池中工作线程的线程工厂，用于创建线程，一般默认的即可
- handler：拒绝策略，表示当队列满了，并且工作线程大于等于线程池的最大线程数（maximumPoolSize）时如何来拒绝请求执行的runnable的策略
（重要）底层工作原理
-
在创建了线程池后，开始等待请求。
-
当调用execute()方法添加一个请求任务时，线程池会做出如下判断：
- 如果正在运行的线程数量小于corePoolSize，那么马上创建线程运行这个任务；
- 如果正在运行的线程数量大于或等于corePoolSize，那么将这个任务放入队列；
- 如果这个时候队列满了且正在运行的线程数量还小于maximumPoolSize，那么还是要创建非核心线程立刻运行这个任务；
- 如果队列满了且正在运行的线程数量大于或等于maximumPoolSize，那么线程池会启动饱和拒绝策略来执行。
-
当一个线程完成任务时，它会从队列中取下一个任务来执行。
-
当一个线程无事可做超过一定的时间（keepAliveTime）时，线程会判断：
- 如果当前运行的线程数大于corePoolSize，那么这个线程就被停掉。
- 所以线程池的所有任务完成后，它最终会收缩到corePoolSize的大小。
拒绝策略
- AbortPolicy(默认)：直接抛出RejectedExecutionException异常阻止系统正常运行
- CallerRunsPolicy：“调用者运行”一种调节机制，该策略既不会抛弃任务，也不会抛出异常，而是将某些任务回退到调用者，从而降低新任务的流量。
- DiscardOldestPolicy：抛弃队列中等待最久的任务，然后把当前任务加人队列中尝试再次提交当前任务。
- DiscardPolicy：该策略默默地丢弃无法处理的任务，不予任何处理也不抛出异常。如果允许任务丢失，这是最好的一种策略。
注意
Stream流式计算
Stream是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列
四大函数式接口
代码
list.stream()
.filter(p -> {return p.getId() % 2 == 0;})
.filter(p -> {return p.getAge() > 24;})
.map(f -> {return f.getUserName().toUpperCase();})
.sorted((o1, o2) -> {return o2.compareTo(o1);})
.limit(1)
.forEach(System.out::println);
分支合并框架ForkJoin
/**
* ForkJoin分支合并框架
* ForkJoinPool、ForkJoinTask、Recursive（递归）Task
* 核心思想：通过递归将一个线程不断fork拆分多个子线程，最后join合并，继承RecursiveTask抽象类，实现computer方法
*
* @author xlj
* @date 2020/10/27 22:44
*/
class MyTask extends RecursiveTask<Integer> {
private static final Integer LIMIT_VALUE = 10;
// 计算初始值
private int start;
// 计算结束值
private int end;
// 结果
private int result;
public MyTask(int start, int end) {
this.start = start;
this.end = end;
}
@Override
protected Integer compute() {
// 当任务较小，无需拆分
if ((end - start) <= LIMIT_VALUE) {
for (int i = start; i <= end; i++) {
result += i;
}
} else {
int middle = (end + start) / 2;
// 递归fork拆分
MyTask myTask1 = new MyTask(start, middle);
MyTask myTask2 = new MyTask(middle + 1, end);
myTask1.fork();
myTask2.fork();
result = myTask1.join() + myTask2.join();
}
return result;
}
}
public class ForkJoinDemo {
public static void main(String[] args) throws ExecutionException, InterruptedException {
// 资源类
MyTask myTask = new MyTask(50, 100);
// 线程池
ForkJoinPool forkJoinPool = new ForkJoinPool();
// 线程-操作-资源类
ForkJoinTask<Integer> task = forkJoinPool.submit(myTask);
// 通过get方法获取返回值
System.out.println("hello，ForkJoin");
System.out.println(task.get());
forkJoinPool.shutdown();
}
}
异步回调
public class CompleteFutureDemo {
public static void main(String[] args) throws Exception {
// 异步无返回值
CompletableFuture<Void> runAsync = CompletableFuture.runAsync(() -> {
System.out.println(Thread.currentThread().getName() + "执行完毕，无返回值");
});
runAsync.get();
// 异步回调，有返回值-----supplyAsync(供给型接口---无传入参数，有返回值)
CompletableFuture<Integer> supplyAsync = CompletableFuture.supplyAsync(() -> {
System.out.println(Thread.currentThread().getName() + "执行完毕，有返回值");
// int a = 10/0;
return 1024;
});
supplyAsync.whenComplete((t, u) -> {
System.out.println("********" + t);
System.out.println("********" + u);
}).exceptionally(t -> {
System.out.println("*********" + t.getMessage());
return 404;
}).get();
}
}
354
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
