并发编程（多线程基础、并发包基础、并发容器与工具、其他）

最新推荐文章于 2022-07-17 16:17:14 发布

向上的小张

最新推荐文章于 2022-07-17 16:17:14 发布

阅读量78

点赞数 1

文章标签：并发编程

本文链接：https://blog.csdn.net/weixin_43888912/article/details/118304989

版权

多线程基础

基础概念：
线程:操作系统能够进⾏运算调度的最⼩单位。它被包含在进程之中，是进程中的实际运作单位。
创建线程的方法

继承thread，重写run方法
实现Runnable接口， new Thread(子类对象).start()
实现Callable接口,重写call方法

并发性：单核CPU分片并发不明显，只是进程，多核线程出现了，为了并行化
Object.wait
thread.join等待线程结束
start开启线程并不是启动
CAS比较的交换操作
在这里插入图片描述
同步：最常见的变成手段，是指任务发起方和执行方在同一线程中完成。
异步：常见的提升吞吐手段，是指任务发起方和执行方在不同一线程中完成。
JDK9：StackWalker.getInstance();输出堆栈信息
// Thread.suspend() 和 Thread.resume() 方法可以运用任意区域
// suspend()：指定线程挂起，resume()：指定线程恢复
// Object.wait() 和 Object.notify() 只能用在 synchronized 方法或块
// 通过对象 Monitor 控制线程状态
thread.join的源码实现本质是object.wait方法，wait释放持有锁

工作实际使用:

如何终止一个进程?

1. interrupt中断线程  ，不能终止线程，但是可以传递interrupt状态。
2. 设定标志位 判断后返回return；

在这里插入图片描述

为什么弃用thread.stop？

因为线程不安全的情况，由于执行stop方法，如果当前对象正在获取到锁的状态，被其他线程调用stop方法,释放锁，加锁操作是为了保护对象数据，释放后其他线程看该对象数据不一致，导致了安全性问题。

获取线程信息操作类

1. 获取线程ID
2. 获取线程时间

在这里插入图片描述

并发理论基础

并发（Concurrent），在操作系统中，是指一个时间段中有几个程序都处于已启动运行到运行完毕之间，且这几个程序都是在同一个处理机上运行。
并行（Parallel），当系统有一个以上CPU时，当一个CPU执行一个进程时，另一个CPU可以执行另一个进程，两个进程互不抢占CPU资源，可以同时进行，这种方式我们称之为并行(Parallel)。
在这里插入图片描述
线程安全实现手段:重进入、线程本地存储、不可变对象、互斥、原子操作同步的实现：信号量（Semaphores）、屏障(Barriers)、互斥(Mutex)、条件变量、自旋锁、读写锁
同步引入的问题：死锁、饥饿、优先级倒转、繁忙等待
Java线程池：ExecutorService是线程池

	 1. newCachedThreadPool 创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
	 2. newFixedThreadPool 创建一个定长线程池，**可控制线程最大并发数**，超出的线程会在队列中等待。
     3. newScheduledThreadPool 创建一个定长线程池，**支持定时及周期性任务执行**。
	 4. newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，**保证所有任务按照指定顺序**(FIFO, LIFO, 优先级)执行。

并发包基础

**
重进入锁：sychronized API的一个实现、隐性的monitor锁、实现方法是lock.lock、lock.unlock方法、互斥、重进入
Lock机制:Acquire获得锁 ->Thread 进入 synchronized -> 获得锁

  Release释放锁->{
                                         当 Thread（hold lock），调用 Object#wait() 时候，释放锁
                                         Thread park -> LockSupport.park(Object)
                                         //真正让线程停止下来(阻塞)，Java提供了一个较为底层的并发工具类:LockSupport，该类常用的方法有两个,1 LockSupport.park(this);表示阻塞指定线程，2、unpark(Thread thread) 唤醒指定线程
                                         Condition#await()
                                         运行期异常，Thread 消亡
                                         Java 9 自旋// Thread.onSpinWait();
                                         Thread.yield();
                                      }

公平（Fair）线程 FIFO 非公平（Nonfair）线程随线程调度
最佳实践：在创建线程时，除非必要，不要调整线程优先级（Priority）
重进入读写锁：事务读事务写，读是共享锁，写锁是协占锁ReentrantReadWriteLock
邮票锁：乐观锁，版本的概念
三种锁：读\写\优化读JUC是属于JVM级别单机并发控制
AQS:
CAS:是一种相对MB内存屏障（重量级锁）的强量级的锁
AtomicBoolean set get操作均为 volatile的语义
多线程CountDownLatch,当count适量 =0，才会释放，latch.await，线程池复用
Lock ->Condition精准的通知和唤醒线程购买->下订单->付款

class Data3{
private Lock lock=new ReentrantLock();
private Condition conditionA=lock.newCondition();//A监视器
private Condition conditionB=lock.newCondition();//B监视器
private Condition conditionC=lock.newCondition();//C监视器
private int number=1;
public void printA(){
lock.lock();
try {
//业务
while(number!=1){
conditionA.await();
}
System.out.println(Thread.currentThread().getName()+"------AAAAAAA");
number=2;//指定唤醒线程
conditionB.signal();
}catch (Exception e){
e.printStackTrace();
}finally {
lock.unlock();
}
}

并发包容器与工具

**
1、8锁的问题：sychronized修饰方法时，锁的对象是方法的调用者，如果方法也被static修饰，静态方法，类一加载就拥有了锁，锁的是class。
2、ArrayList不安全，线程会出现并发修改异常concurrentmodificationexception解决方案；
1. List list = new Vector<>();
2. List list = Collections.synchronizedList(new ArrayList<>());
3. List list = new CopyOnWriteArrayList<>()；
同理set

3、常用辅助类具体方法见-线程 -0301-practice-demo
CountDownLatch:辅助工具类用于计数、减法计数器 coutDown 、await
CyclicBarrier：加法计数器 await
Semaphore：信号量，抢车位 6个车子，3个位置限流会使用 aquire得到 release释放
4、读写锁
ReentrantReadWriteLock重入读写锁
private ReadWriteLock readWriteLock=new ReentrantReadWriteLock();1
private Lock lock=new ReentrantLock();2
写写不能共存1
读读可以共存2
读写不能共存1
独占锁（写锁）一次只能被一个线程占有readWriteLock.writeLock().lock();
共享锁（读锁）多个线程可以被同时占有readWriteLock.readLock().lock();
5、堵塞队列
在这里插入图片描述
队列：FIFO先进先出
API ：

6、SychronousQueue同步队列
没有容量，进去一个元素，必须等待取出来后，才能放元素。
put take，不存储元素，放入就取出类似于信号量
7、线程池（重点）三大方法七大参数四种拒绝策略
池化技术：程序的运行本质是占用系统资源，优化资源的使用，引用池化技术，类似线程池、连接池、内存池、对象池。
池化技术：事前准备好资源，用就取，使用后归还。
默认大小、MAX、 MIN
线程池的好处：降低资源的消耗、提高响应速度、方便管理、线程复用、可以精致最大并发数、管理线程
在这里插入图片描述
七大参数

四种拒绝策略
在这里插入图片描述

拒绝策略，不处理，并抛出异常
new ThreadPoolExecutor.AbortPolicy() 银行满了，还有人进来，不处理这个人的，抛出异常
new ThreadPoolExecutor.CallerRunsPolicy() // 哪来的去哪里！
new ThreadPoolExecutor.DiscardPolicy() //队列满了，丢掉任务，不会抛出异常！
new ThreadPoolExecutor.DiscardOldestPolicy() 队列满，尝试去和最早的竞争也不会抛出异常！

四大函数式接口（必须掌握）

1、函数式接口：只有一个方法的接口
Consume消费型：只有输入没有返回值 accept方法
Supplier供给型接口:没有参数，只有返回值
断定型接口：有一个输入参数，返回值只能是布尔值！
Predicate predicate = (str)->{return str.isEmpty(); };
2、链式编程
3、函数式接口
4、Stream流式计算
大数据=存储+计算
存储=集合+Mysql
计算都交给流操作
Demo
在这里插入图片描述
**

ForkJoin-JDK1.7并行执行任务，提高效率，大数据量上亿数据

**
大任务分成小任务、特点：工作窃取、

JMM：Java内存模型，不存在的东西，概念，一种约定。
1. 线程解锁前，将共享变量立刻刷回主存
2. 线程枷锁前，立刻读取主存中的变量到线程工作内

Volatile是Java虚拟机的轻量级同步机制
1. 保证可见性
在这里插入图片描述

2.不保证原子性
3.禁止指令重排

锁的理解

1. 公平锁、非公平锁(默认)
2. 可重入锁:拿到外面的锁，里面的锁也拿到了
3. 自旋锁:不断的尝试，直到成功
4. 死锁

jps -l //定位进程号
jstack 进程号 //查看信息
工作排查问题：查看日志、堆栈信息、

向上的小张

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
并发编程（多线程基础、并发包基础、并发容器与工具、其他）

多线程基础基础概念：线程:操作系统能够进⾏运算调度的最⼩单位。它被包含在进程之中，是进程中的实际运作单位。创建线程的方法继承thread，重写run方法实现Runnable接口， new Thread(子类对象).start()实现Callable接口,重写call方法并发性：单核CPU分片并发不明显，只是进程，多核线程出现了，为了并行化Object.waitthread.join等待线程结束start开启线程并不是启动CAS比较的交换操作同步：最常见的变成手段，是指任务发起方
复制链接

扫一扫