Java进阶——多线程

​
​

活动地址：优快云21天学习挑战赛

多线程

创建线程的三种方式

1.继承Thread类，并且重写run方法
Thread中的run不是抽象方法，Thread不是抽象类 MyThread继承了Thread类之后，它就是一个独立的线程。要让线程启动，调用线程的start方法
Thread可以传线程名字和name
当调用start方法启动一个线程时，会执行重写的run方法的代码
一定是调的start不是run，直接调用run不属于线程，与继承无关

90有限主方法，百分之10有限跑Mythread 先跑哪个线程是有概率的
Mythread 中输出2 主方法 134 大概率1342
start方法是Thread类里的

实现Runnable接口 （函数式接口）
如果想让线程启动，必须调用Thread类中的start方法

使用箭头函数 (Lambda表达式)

实现Callable接口

守护线程

java中提供两种类型的线程：
1.用户线程
2.守护线程
守护线程为用户线程服务，仅用户线程运行时才需要
守护线程队后台支持的任务非常有用。 (垃圾回收)大多数JVM线程都是守护线程
github gitee APK
创建守护线程 代码操作基本都是守护线程
任何线程继承创建它的线程守护进程状态，由于主程序是用户线程，因此mian方法内启动的任何线程默认都是守护线程
线程的生命周期 大写
new这个状态主要是线程未被start()调用执行
Runnable 线程正在JVM中被执行，等待来自操作系统的调度
blocked 阻塞，因为某些原因不能立即执行需要挂起等待

wating 无限期等待。需要依赖Object类。如果没有唤醒，就一直等待
timed_waiting ：有限的等待，线程等待一个指定的时间
terminated 线程执行完毕。终止线程的状态
等待和阻塞很像，阻塞是因为外部原因需要等，而等待是主动等待
主动调用方法来发起主动等待，可以传参确定等待时间，但一般不传
join方法的本意是阻塞主线程

CPU多核缓存结构

物理内存：硬盘 (固态硬盘，尽量不使用混合)
CPU缓存：为了提高程序运行的性能 CPU很多方没会对程序进行优化 cpu的处理速度是最快的，内存次之，硬盘最慢 如果内存运行慢会影响cpu ，为了解决这种问题，cpu设计了多级缓存策略 :每个cpu都有L1和L2级缓存，L3公用

volatile 关键字
可见性
加锁 synchronized 同步锁
Thread.sleep(); 休眠

锁

1.synchronized
重量级的锁，jdk1.6对synchronized进行优化 为了减少获得锁和释放锁带来的性能的消耗，引入了偏向锁和轻量级锁
synchronized 三种加锁方式：
1.修饰成员（实例）方法 作用于当前实例加锁，进入同步代码之前要获得当前实例的锁
2.静态方法：作用域当前类对象加锁，进入同步代码前要获得当前类对象的锁
3.代码块：指定加锁对象，给指定的对象加锁，进入同步代码块之前要获得给定对象的锁
synchronized(){}
1.创建一个对象
2.类对象 Ch01.class
3.当前实例this
对象：
1.实例方法：调用该方法的实例
2.静态方法：类对象
3.this：代表调用该方法的实例对象
4.类对象:
操作共享数据的代码
共享数据：多个线程共同操作的变量，可以充当锁
当使用synchronized 锁的东西就是this(当前对象)
同步代码块使用：
private static Object obj=new Object();
public void run(){
sychronized(obj){} （Ch02.obj）
}
Thread t1=new Thread(new window(“窗口一”))

也可以在obj的地方加入类对象
window.class 不需要加入新对象
1.同步方法依然会涉及到同步锁对象，不需要写出来
2.非静态方法的同步锁就是this
静态的同步方法，同步监视器就是类本身
同步代码块
1.要选好同步监视器（锁）推荐使用类对象，第三方对象，this
2.实现箭扣创建的线程类中。同步代码块不可以用this充当同步锁
用了同步可以解决线程安全问题，但是只有一个线程可以参与，相当于单线程过程，效率低
synchronized只针对于当前JVM可以解决线程安全问题 也就是不可以跨JVM解决问题

死锁

死锁情景：多个线程同时被阻塞，他们中的一个或者多个都在等待某个资源的释放，由于线程无限期的堵塞，程序就不可能正常终止。
java死锁产生的必要条件：
1.互斥使用，当资源被一个线程使用（占用），别的线程不能使用
2.不可抢占，资源的请求者不能强制从占有者中抢夺资源，资源只能从占有者手动释放
3.请求和保持
4.循环等待，存在一个等待的队列。p1占有p2资源 p2占p3 p3 占p1 都不释放形成等待环路
线程重入
任意的线程拿到锁之后，再次获得的时候不会被该锁阻碍
线程不会被自己锁死，这叫线程的重入，synchronized可重入锁
jdk1.5之后锁升级
1.无锁，不加锁
2.偏向锁：不锁锁，当只有一个线程争夺时，会偏向或一个线程，这个线程不加锁
3.轻量级锁：少量线程来了之后，先尝试自旋，不挂起线程。
4.重量级锁：排队挂起(暂停)线程 （synchronized）
挂起线程和恢复线程需要转入内核态中完成这些操作，会给系统的并发现带来很大压力，在许多应用上共享数据的锁定状态，只会持续很短的时间，为了这段时间去挂起和恢复并不值得，我们可以让后面的线程等待一下，不用放弃处理器的执行时间。锁为了让线程等待，我们只需要让线程执行一个循环，自旋【自旋锁】

Object类对多线程的支持

Object的成员方法
wait(); wait(long timeout ); (搁多久进来，可主动提前叫进来) 当前线程进入等待状态
notify()；唤醒正在等待的下一个线程 notifyAll(); 唤醒正在等待的所有线程
线程间的通信：两条线程共同运行，线程A如果先走，线程B就要等待，A走完唤醒B,B走
方法总结：
1.Thread两个静态方法：
sleep释放CPU资源，但是不会释放锁
yield方法，释放CPU的执行权，但是保留CPU的执行资格，不常用
2.join方法：yield出让了执行权，join就加入进来
3.wait:释放CPU的资源， 放锁
notify 唤醒等待中的线程
notifyAll:唤醒等待中的所有线程
面试题：sleep和wait 区别
1.出处 2.锁的控制

线程的退出

使用退出标志来让线程正常推出，run方法结束后线程终止
interrupt方法 中断线程
/*Class MyThread extends Thread{
private boolean flag =true}

public void StopThread(){ 停止方法
this flag=false; }*/
thread.interrupt();
interrupt方法会抛出异常，捕获后再做停止线程的逻辑即可
如果whlie(true)运行的状态，interrupt叫不醒 别在main加死循环
建议用volatile volatile修饰一个属性 就是把它写进了内存不是缓存
线程的常用方法：
Thread类中的方法
1.start：启动当前线程，执行run方法
2.run;
3.currentThread 静态方法，获取当前正在执行的线程
4.getName() 获取当前线程的name 这几个可以直接写
5.getId() 返回此线程的唯一标识
6.setName() 设置当前线程的name
7.getPriority() 获取当前线程的优先级
8.setPriority(int) 设置当前线程的优先级
9.getState() 获取当前线程的生命周期
10.interrupt() 中断线程的执行
11.inetrrupted() 查看当前线程是否被中断
枚举：天生构造器私有化，适合单例模式

LockSupport 工具类 (含锁)

线程阻塞的工具类，所有的方法都是静态方法，可以让线程在任意位置阻塞，阻塞之后也有唤醒的方法。
park: 停车。把Thread看成一个车，park就是让车停下来
unpark(传参):让车启动跑起来
LockSupport.park();
park和unpark实现了wait和notify的功能
1.park不需要获取某个对象的锁(不释放锁)
2.park不会抛出异常，需要park之后自行判断中断状态，然后做额外处理
LockSupport.getBlocker(t1) 获取信息
总结：
1.park和unpark实现了wait和notify的功能 但是并不和wait和notify交叉使用
2.park和unpark不会死锁(不释放锁)
3.blocker的作用看到阻塞对象的信息

Lock锁

Lock是一个接口 (接口不能实例化)
lock.lock(); 加锁
public void show(){
Lock lock=new Lock();
lock.lock();
try{
处理业务逻辑
}
catch(Exception e){
异常处理
}
finally{ 释放锁即释放资源 lock.unlock(); }
}

tryLock 判断有没有拿到锁if()else()
优先级：lock->sy代码块->sy方法
Lock接口的实现类：
ReentrantLock 可重入锁 实现了Lock接口
ReentrantLock lock=new ReentrantLock();

synchronized和ReentrantLock的区别
1.Lock是一个接口 synchronized是一个关键字，是由底层语言©实现的
2.synchronized发生异常的时候，会自动释放线程占用的锁，不会发生死锁
Lock发生异常如果没有主动释放，极有可能占用资源不放手
3.Lock可以让等待锁的线程中断，使用synchronized只会让等待的线程一直等待下去，不能让线程中断
4.Lock可以提高多个线程进行读操作的效率
Lock以下功能是synchronized不具备的
ReentrantReadWriteLock 读写锁
对于一个应用而言，一般情况读的操作远远多于写的操作，如果仅仅是读的操作没有写，数据又是线程安全的，读写锁给我们提供了一种锁，读的时候可以很多线程一起读，但是不能由线程写，写操作是独占的，当有线程在执行写的操作，其他的线程既不能读也不能写。
private staic Reen =new Reen();
main
Runnable read()->{
ReentrantReadWriteLock.ReadLock readLock =Lock.readLock();
readLock.lock();
try
};
Runnable write()->{
ReentrantReadWriteLock.WriteLock writeLock=Lock.writeLock();
writeLock.lock();
};
for(int i=0;i<100;i++){
Random random=new Random
int flag=random.nextInt(100)
if(flag>20){
}}
在某些场景下能极大的提高效率
Lock锁的原理cas和aqs
synchronized是由C语言实现的，只能作为关键字使用，java提供了一些并发的编程的包，底层的实现原理cas和aqs
并发编程的三大特性：
1.原子性：原子的操作可以是一个步骤也可以是多个步骤，但是顺序不饿能乱，也不可以被切割，只执行其中的一部分，将整个操作视为一个整体，原子性不仅仅是多行代码，也可能是多条指令。
2.可见性
3.有序性
CAS：比较并交换。jdk11改成:比较并设置
思路：就是给一个元素赋值的时候，先看看内存里的那个值到底变没变
AQS：抽象队列同步器，解决线程同步执行的问题 双向链表
JUC并发编程包：
1.原子类Atomic

AtomicInteger poolNumber=new AtomicInteger();

线程池
使用线程池 (便于管理，提高线程)
1降低资源的消耗，通过重复利用已创建的线程，降低创建和销毁线程造成的消耗
2提高响应的速度，当任务到达时，任务可以不需要等到线程创建就立即执行
3提高线程的可管理性。线程比较稀缺的资源，如果无限制的创建，不仅消耗系统资源，还会降低系统稳定性，使用线程池可以进行统一分配，调优和监控。
jdk自带的四种线程池：
Executars
1.newCachedThreadPool 创建一个可缓存的线程池，如果线程池长度超过处理需要，可以灵活回收空闲线程，如果无可回收，就创建新线程
2.newFixedThreadPool:创建一个定长(指定长度)的线程池，可控制最大并发数，超出的线程会在队列中等待
3.newScheduledThreadPool：创建一个定长线程池，支持定时及周期性任务执行、
4.newSingleThreadExecutor:创建一个单线程化的线程池，只会用唯一的工作线程来执行任务，保证所有的任务按照指定顺序进行
这四种线程池的初始化都调用了同一个构造器
参数的意义：
ThreadPool
corePoolSize：线程池里线程的数量，核心线程池大小
maximumPoolSize 规定最大的线程数量
keepAliveTime: 当线程池线程数量大于核心大小，多出的空闲线程多久销毁
TimeUnit unit 时间单位
workQueue:任务队列，用于存放提交但是尚未被执行的任务
threadFactory：线程工厂，用来创建线程，线程工厂就是我们new线程的
RejectedExcutionHandler handler 拒绝策略:拒绝该任务采取的响应措施
四种拒绝策略：
AboutPolicy ：直接抛出异常
CallerRunPolicy: 用调用者所在的线程来执行任务
DiscardOldestPolicy:丢弃阻塞队列中最靠前的任务，并执行当前任务
DiscardPolicy:直接丢弃任务

1.创建线程的四种方式
2.线程的同步 synchronized ReentrantLock 以及 读写锁
3.线程之间的通信 wait notify notifyALl
4.线程类的常用方法