JUC
JUC是java.util .concurrent工具包的简称
线程和进程
- 进程：一个程序，例如QQ.exe Music.exe 程序；
- 一个线程默认有2个线程：main线程（主线程）和GC线程（垃圾回收）
- java并不能开启线程，因为java运行在虚拟机之上，不能直接调用硬件，通过调用本地方法（native）开启线程。
// 本地方法，底层的C++ ，Java 无法直接操作硬件
private native void start0();- 并发：多线程操作统一资源。CPU一核，通过快速切换线程，实现线程的并发执行。
- 并行：CPU多核，多个线程可以同时执行。
//获取CPU的核数
System.out.Println(Runtime.getRuntime().availableProcessors());- 线程的6种状态：创建(NEW)、RUNNABLE(运行)、BLOCKED(阻塞)、WAITING(等待)、TIMED_WAITING(超时等待)、TERMINATED(终止)
wait和sleep的区别
1.所属的类不同：wait属于Object, sleep属于Thread
2.锁的释放：wait会释放锁，sleep不会释放锁
3.使用的范围不同：wait在同步代码块和同步方法中，sleep没有范围的限制
Lock锁
Synchronized
public class SynchronizedTest {
public static void main(String[] args) {
Ticket ticket = new Ticket();
new Thread(()-> {for (int i = 0; i < 40; i++) { ticket.saleTicket();}},"A").start();
new Thread(()-> {for (int i = 0; i < 40; i++) { ticket.saleTicket();}},"B").start();
new Thread(()-> {for (int i = 0; i < 40; i++) { ticket.saleTicket();}},"C").start();
}
}
/**
* 公司使用多线程开发时，线程就是一个单独的资源类，
* 没有任何附属的操作，从而降低耦合性
*
*/
class Ticket
{
private int tickets = 60;
//卖票
public synchronized void saleTicket()
{
if(tickets > 0){
System.out.println(Thread.currentThread().getName()+"买了第"+tickets+"张票"+"剩余票数："+ --tickets);
}
}
}Lock接口
- 所有实现类：[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7UyU7a9E-1603071924216)(C:\Users\yxz\AppData\Roaming\Typora\typora-user-images\image-20200927193530376.png)]
- 在ReentranLock类中可以设置公平锁（先来后到）和非公平锁（可以插队–默认）
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class ReentranLockTest {
public static void main(String[] args) {
TicketClass ticket = new TicketClass();
new Thread(()-> {for (int i = 0; i < 40; i++) { ticket.saleTicket();}},"A").start();
new Thread(()-> {for (int i = 0; i < 40; i++) { ticket.saleTicket();}},"B").start();
new Thread(()-> {for (int i = 0; i < 40; i++) { ticket.saleTicket();}},"C").start();
}
}
/**
* 资源类
*/
class TicketClass
{
private int tickets = 60;
Lock lock = new ReentrantLock();
//卖票
public void saleTicket()
{
//加锁
lock.lock();
try {
if(tickets > 0){
System.out.println(Thread.currentThread().getName()+"买了第"+tickets+"张票"+"剩余票数："+ --tickets);
}
}
catch(Exception e){
e.printStackTrace();
}
finally {
//释放锁
lock.unlock();
}
}
}Synchronized和Lock的区别
- Synchronized 内置的Java关键字， Lock 是一个Java类
- Synchronized 无法判断获取锁的状态，Lock 可以判断是否获取了锁
- Synchronized 会自动释放锁，Lock 必须要手动释放锁，如果不释放锁，有可能造成死锁
- Synchronized中的线程 1获得了锁但进入阻塞态，此时线程2会一直等待下去；在Lock锁中线程不一定会等待
- Synchronized和Lock锁都是可重入锁。Synchronized不可以中断，非公平锁。Lock锁可以设置是否为公平锁并且可以判断是否获得了锁
- Synchronized 适合锁少量的代码同步问题，Lock 适合锁大量的同步代码
生产者和消费者问题
Synchronized处理生产者和消费者问题
public class SynProCon {
public static void main(String[] args) {
ProCon proCon = new ProCon();
new Thread(()->{for (int i = 0; i < 40; i++) {proCon.Produce();}},"A").start();
new Thread(()->{for (int i = 0; i < 40; i++) {proCon.Consume();}},"B").start();
}
}
/*
* 判断等待-->业务-->通知
*/
class ProCon{
private int number = 0;
//生产商品
public synchronized void Produce(){
if(number != 0){
try {
//等待
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
number++;
System.out.println(Thread.currentThread().getName()+"生产完成");
this.notifyAll();
}
//消费商品
public synchronized void Consume(){
if(number == 0){
try {
//等待
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
number--;
System.out.println(Thread.currentThread().getName()+"消费完成");
this.notifyAll();
}
}当有两个或者两个以上的生产者（消费者）会存在虚假唤醒----number的会出现大于1的情况。
解决方法：线程的等待要在循环中，而不是for中
while(number == 0){
try {
//等待
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}JUC处理生产者和消费者问题
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class LockContionTest {
public static void main(String[] args) {
ProConClass proCon = new ProConClass();
new Thread(()->{for (int i = 0; i < 40; i++) {proCon.Produce();}},"A").start();
new Thread(()->{for (int i = 0; i < 40; i++) {proCon.Consume();}},"B").start();
}
}
/*
* 判断等待-->业务-->通知
*/
class ProConClass{
private int number = 0;
Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();
//生产商品
public void Produce(){
try {
lock.lock();
while(number != 0){
//等待
condition.await();
}
number++;
System.out.println(Thread.currentThread().getName()+"生产完成");
condition.signalAll();
}catch (Exception e){
e.printStackTrace();
}
finally {
lock.unlock();
}
}
//消费商品
public void Consume(){
try {
lock.lock();
while(number == 0){
//等待
condition.await();
}
number--;
System.out.println(Thread.currentThread().getName()+"消费完成");
condition.signalAll();
}catch (Exception e){
e.printStackTrace();
}
finally {
lock.unlock();
}
}
}Condition可以准确的唤醒某个线程或者让某个线程等待
例：A、B、C三个线程按顺序执行 A–>B–>C
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class ThreadOrderExe {
public static void main(String[] args) {
Model model = new Model();
new Thread(()->{for (int i = 0; i < 40; i++) model.PrintA();},"A").start();
new Thread(()->{for (int i = 0; i < 40; i++) {model.PrintB();}},"B").start();
new Thread(()->{for (int i = 0; i < 40; i++) {model.PrintC();}},"C").start();
}
}
/*
* 判断等待-->业务-->通知
*/
class Model{
private int number = 1;
Lock lock = new ReentrantLock();
Condition condition1 = lock.newCondition();
Condition condition2 = lock.newCondition();
Condition condition3 = lock.newCondition();
//打印A
public void PrintA(){
lock.lock();
try{
if(number != 1){
condition1.await();
}
System.out.println("AAAAAAAAAAAAAAAA");
number = 2;
condition2.signal();
}
catch(Exception e){
e.printStackTrace();
}
finally {
lock.unlock();
}
}
//打印B
public void PrintB(){
lock.lock();
try{
if(number != 2){
condition2.await();
}
System.out.println("BBBBBBBBBBBBBBB");
number = 3;
condition3.signal();
}
catch(Exception e){
e.printStackTrace();
}
finally {
lock.unlock();
}
}
//打印C
public void PrintC(){
lock.lock();
try{
if(number != 3){
condition3.await();
}
System.out.println("CCCCCCCCCCCCCCCCCCCCC");
number = 1;
condition1.signal();
}
catch(Exception e){
e.printStackTrace();
}
finally {
lock.unlock();
}
}
}8锁现象
synchronized 锁的对象是方法的调用者！
1.先发短信，再打电话
2.先发短信，再打电话
import java.util.concurrent.TimeUnit;
/**
* 8锁，就是关于锁的8个问题
* 1、标准情况下，两个线程先打印 发短信还是 打电话？ 1/发短信 2/打电话
* 2、sendSms延迟4秒，两个线程先打印 发短信还是 打电话？ 1/发短信 2/打电话
*/
public class Test1 {
public static void main(String[] args) {
Phone phone = new Phone();
//锁的存在
new Thread(()->{phone.sendSms()},"A").start();
// 捕获
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{phone.call();},"B").start();
}
}
class Phone{
// synchronized 锁的对象是方法的调用者！、
// 两个方法用的是同一个锁，谁先拿到谁执行！
public synchronized void sendSms(){
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("发短信");
}
public synchronized void call(){
System.out.println("打电话");
}
}3.先Hello，再短信
4.先打电话，在发短信
import java.util.concurrent.TimeUnit;
/**
* 3、 增加了一个普通方法后！先执行发短信还是Hello？ 普通方法
* 4、 两个对象，两个同步方法， 发短信还是 打电话？ // 打电话
*/
public class Test2 {
public static void main(String[] args) {
// 两个对象，两个调用者，两把锁！
Phone2 phone1 = new Phone2();
Phone2 phone2 = new Phone2();
//锁的存在
new Thread(()->{phone1.sendSms();},"A").start();
// 捕获
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{phone2.call();},"B").start();
}
}
class Phone2{
// synchronized 锁的对象是方法的调用者！
public synchronized void sendSms(){
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("发短信");
}
public synchronized void call(){
System.out.println("打电话");
}
// 这里没有锁！不是同步方法，不受锁的影响
public void hello(){
System.out.println("hello");
}
}5.先发短信，在打电话
6.先发短信，在打电话
import java.util.concurrent.TimeUnit;
/**
* 5、增加两个静态的同步方法，只有一个对象，先打印 发短信？打电话？
* 6、两个对象！增加两个静态的同步方法， 先打印 发短信？打电话？
*/
public class Test3 {
public static void main(String[] args) {
// 两个对象的Class类模板只有一个，static，锁的是Class
Phone3 phone1 = new Phone3();
Phone3 phone2 = new Phone3();
//锁的存在
new Thread(()->{
phone1.sendSms();
},"A").start();
// 捕获
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
phone2.call();
},"B").start();
}
}
// Phone3唯一的一个 Class 对象
class Phone3{
// synchronized 锁的对象是方法的调用者！
// static 静态方法
// 类一加载就有了！锁的是Class
public static synchronized void sendSms(){
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("发短信");
}
public static synchronized void call(){
System.out.println("打电话");
}
}7.先打电话，在发短信
8…先打电话，在发短信
package com.kuang.lock8;
import java.util.concurrent.TimeUnit;
/**
* 7、1个静态的同步方法，1个普通的同步方法 ，一个对象，先打印 发短信？打电话？
* 8、1个静态的同步方法，1个普通的同步方法 ，两个对象，先打印 发短信？打电话？
*/
public class Test4 {
public static void main(String[] args) {
// 两个对象的Class类模板只有一个，static，锁的是Class
Phone4 phone1 = new Phone4();
Phone4 phone2 = new Phone4();
//锁的存在
new Thread(()->{
phone1.sendSms();
},"A").start();
// 捕获
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
phone2.call();
},"B").start();
}
}
// Phone3唯一的一个 Class 对象
class Phone4{
// 静态的同步方法 锁的是 Class 类模板
public static synchronized void sendSms(){
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("发短信");
}
// 普通的同步方法 锁的调用者
public synchronized void call(){
System.out.println("打电话");
}集合类不安全
List不安全
import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;
public class ListUnsafeTest {
public static void main(String[] args) {
//多线程操作List集合时，导致List不安全:java.util.ConcurrentModificationException
// List<String> list = new ArrayList<>();
//1.解决方案1
// List<String> list = new Vector<>();
//解决方案二
// List<String> list = Collections.synchronizedList(new ArrayList<>());
//解决方案三
List<String> list = new CopyOnWriteArrayList<>();
for (int i = 1; i <= 6; i++) {
new Thread(()->{
list.add(UUID.randomUUID().toString().substring(0,5));
System.out.println(list);
},String.valueOf(i)).start();
}
}
}- Vector方案效率不如CopyOnWriteArrayList，因为Vector的add方法用Synchronized修饰
- CopyOnWriteArrayList为写入时复制，COW是计算机设计领域的一种优化策略
set不安全
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.CopyOnWriteArraySet;
public class SetUnsafeTest {
public static void main(String[] args) {
//Set<String> set = new HashSet<>();
//解决方案1：
//Set<String> set = Collections.synchronizedSet(new HashSet<>());
//解决方案2：
Set<String> set = new CopyOnWriteArraySet<>();
for (int i = 1; i <= 6; i++) {
new Thread(()->{
set.add(UUID.randomUUID().toString().substring(0,5));
System.out.println(set);
},String.valueOf(i)).start();
}
}
}- HashSet底层是HashMap，add set 本质是map key 是无法重复的
Map不安全
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
public class MapUnsafeTest {
public static void main(String[] args) {
//Map不安全
// Map<String,String> map = new HashMap<>();
//解决方案
Map<String,String> map = new ConcurrentHashMap<>();
for (int i = 1; i <= 6; i++) {
new Thread(()->{
map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0,5));
System.out.println(map);
},String.valueOf(i)).start();
}
}
}- 工作中一般不用HashMap,默认等价于new HashMap<>(16,0.75)
Callable
- 与runnable的区别：可以有返回值，可以抛出异常，方法不同call()
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class CallableTest {
public static void main(String[] args) throws ExecutionException, InterruptedException {
MyThread thread = new MyThread();
FutureTask futureTask = new FutureTask(thread);
new Thread(futureTask,"A").start();
new Thread(futureTask,"B").start();//结果会被缓存，效率高
Integer integer = (Integer) futureTask.get();
System.out.println(integer);
}
}
class MyThread implements Callable<Integer>{
@Override
public Integer call() {
System.out.println(Thread.currentThread().getName()+"call()");
return 1024;
}
}常用的辅助类
countDownLatch: 只有计数结束后，才往下执行
import java.util.concurrent.CountDownLatch;
public class CountDownLatchTest {
public static void main(String[] args) throws InterruptedException {
//定义CountDownLatch
CountDownLatch count = new CountDownLatch(6);
for (int i = 1; i <= 6; i++) {
new Thread(()->{
System.out.println(Thread.currentThread().getName()+" go out");
//减一操作
count.countDown();
},String.valueOf(i)).start();
}
//等待计数器减为0
count.await();
System.out.println("close door");
}
}CyclicBarrier: 加法计算器
import java.sql.SQLOutput;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
public class CyclicBarrierTest {
public static void main(String[] args){
//加法计算器
CyclicBarrier cyclicBarrier = new CyclicBarrier(6,()->{
System.out.println("执行完成");
});
for (int i = 1; i <= 6; i++) {
final int temp = i;
new Thread(()->{
System.out.println("当前累积计数:"+ temp);
//累积完成，执行剩余任务
try {
cyclicBarrier.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
}).start();
}
}
}Semaphore: 信号量，多个共享资源互斥的使用，并发限流，控制最大的线程数
Semaphore.acquire( ): 获得信号量，假设信号量为0，线程等待直至其它线程释放信号量为止。
Semaphore.release( ): 释放信号量，唤醒等待的线程
import java.sql.Time;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
public class SemaphoreTest {
public static void main(String[] args) {
//定义信号量个数
Semaphore semaphore = new Semaphore(3);
for (int i = 1; i <= 6; i++) {
new Thread(()->{
try {
//获取信号量
semaphore.acquire();
System.out.println(Thread.currentThread().getName() + "抢到车位");
//休息2s
TimeUnit.SECONDS.sleep(2);
System.out.println(Thread.currentThread().getName()+"离开车位");
} catch (InterruptedException e) {
e.printStackTrace();
}
finally {
//释放信号量
semaphore.release();
}
},String.valueOf(i)).start();
}
}
}读写锁
ReadWriteLock：实现类ReentrantReadWriteLock，读可以被多线程同时读，写的时候只能有一个线程去写。
import java.sql.Time;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class ReadWriteLockTest {
public static void main(String[] args) {
MyCache cache = new MyCache();
final int temp = 1;
//10个写线程
for (int i = 1; i <= 10; i++) {
new Thread(()->{
try {
cache.put("Thread", temp);
} catch (InterruptedException e) {
e.printStackTrace();
}
},String.valueOf(i)).start();
}
//10个读线程
for (int i = 1; i <= 10; i++) {
new Thread(()->{
cache.get("Thread");
},String.valueOf(i)).start();
}
}
}
/**
* 自定义缓存
*/
class MyCache{
private volatile Map<String,Object> map = new HashMap<>();
//定义读写类
ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
//存储数据:写线程不能同时进行
public void put(String key, int value) throws InterruptedException {
readWriteLock.writeLock().lock();
System.out.println(Thread.currentThread().getName()+":正在存储数据");
map.put(key,value);
TimeUnit.SECONDS.sleep(1);
System.out.println(Thread.currentThread().getName()+":数据存储成功");
readWriteLock.writeLock().unlock();
}
//读取数据：读写线程不能同时进行，读线程可以同时进行
public void get(String key){
readWriteLock.readLock().lock();
System.out.println(Thread.currentThread().getName()+":正在读取数据");
Object data = map.get(key);
System.out.println(Thread.currentThread().getName()+":数据读取成功");
readWriteLock.readLock().unlock();
}
}BlockingQueue----使用场景：多线程并发操作和线程池
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xBSBAheD-1603071924221)(C:\Users\yxz\AppData\Roaming\Typora\typora-user-images\image-20201013165448225.png)]
- 队列添加和移除：四组API
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pZyaKcFn-1603071924222)(C:\Users\yxz\AppData\Roaming\Typora\typora-user-images\image-20201013165711401.png)]
add方法中，如果队列已满，抛出 IllegalStateException: Queue full异常
remove方法中，如果为空队列，抛出java.util.NoSuchElementException异常
offer方法中。如果队列未满，返回true。如果对列已满，返回false,不抛出异常
poll方法中，如果队列未空，返回true。如果对列已空，返回null,不抛出异常
offer(“d”,2,TimeUnit.SECONDS) – 等待超过2秒就退出
SynchronousQueue 同步队列:没有容量，放一个元素，必须取出来之后，才能放下一个元素
import jdk.nashorn.internal.ir.Block;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.TimeUnit;
public class SynchronousQueueTest {
public static void main(String[] args) {
//定义同步队列
BlockingQueue<String> queue = new SynchronousQueue<>();
new Thread(()->{
try {
System.out.println(Thread.currentThread().getName()+"put 1");
queue.put("1");
System.out.println(Thread.currentThread().getName()+"put 2");
queue.put("2");
} catch (InterruptedException e) {
e.printStackTrace();
}
},"P1").start();
new Thread(()->{
try {
TimeUnit.SECONDS.sleep(2);
System.out.println(Thread.currentThread().getName()+"take" + queue.take());
TimeUnit.SECONDS.sleep(2);
System.out.println(Thread.currentThread().getName()+"take" + queue.take());
} catch (InterruptedException e) {
e.printStackTrace();
}
},"T1").start();
}
}线程池（重点）
线程池：三大方法，7大参数，4种拒绝策略
池化技术：优化资源的使用
线程池的好处：
1、降低资源的消耗
2、提高响应的速度
3、方便管理。4、线程复用、可以控制最大并发数、管理线程
线程池的三大方法：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uvQCOgcR-1603071924225)(C:\Users\yxz\AppData\Roaming\Typora\typora-user-images\image-20201013185635802.png)]
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolTest {
public static void main(String[] args) {
//线程池三大方法
//方法一: 单个线程
ExecutorService service = Executors.newSingleThreadExecutor();
//方法二: 创建固定大小的线程池
// ExecutorService service = Executors.newFixedThreadPool(6);
//方法三：创建动态大小的线程池
// ExecutorService service = Executors.newCachedThreadPool();
for (int i = 1; i <= 20; i++) {
service.execute(()->{
System.out.println(Thread.currentThread().getName()+"ok");
});
}
//执行完成，关闭线程池
service.shutdown();
}
}7大参数：
public ThreadPoolExecutor(
int corePoolSize, //核心线程池的大小
int maximumPoolSize, //线程池中的线程最大数量
long keepAliveTime, // 线程池中的线程超过一段时间没有被调用就会释放
TimeUnit unit, //超时单位
BlockingQueue<Runnable> workQueue, //阻塞队列
ThreadFactory threadFactory, //线程工厂，用于创建线程，一般不动
RejectedExecutionHandler handler) { //拒绝策略
if (corePoolSize < 0 ||
maximumPoolSize <= 0 ||
maximumPoolSize < corePoolSize ||
keepAliveTime < 0)
throw new IllegalArgumentException();
if (workQueue == null || threadFactory == null || handler == null)
throw new NullPointerException();
this.corePoolSize = corePoolSize;
this.maximumPoolSize = maximumPoolSize;
this.workQueue = workQueue;
this.keepAliveTime = unit.toNanos(keepAliveTime);
this.threadFactory = threadFactory;
this.handler = handler;
}[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yKZTT5uK-1603071924227)(C:\Users\yxz\AppData\Roaming\Typora\typora-user-images\image-20201013190855948.png)]
4大拒绝策略：
new ThreadPoolExecutor.AbortPolicy() // 银行满了，还有人进来，不处理这个人的，抛出异常
new ThreadPoolExecutor.CallerRunsPolicy() // 哪来的去哪里！
new ThreadPoolExecutor.DiscardPolicy() //队列满了，丢掉任务，不会抛出异常！
new ThreadPoolExecutor.DiscardOldestPolicy()//队列满了，尝试去和最早任务竞争，不会抛出异常！创建线程池
import java.util.concurrent.*;
public class ThreadPoolDemo {
public static void main(String[] args) {
//自定义线程池
ExecutorService service = new ThreadPoolExecutor(
2,
5,
3,
TimeUnit.SECONDS,
new LinkedBlockingDeque<>(3),
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.DiscardOldestPolicy() // 若队列已满，尝试最早任务竞争，不会抛出异常
);
for (int i = 1; i <= 10; i++) {
service.execute(()->{
System.out.println(Thread.currentThread().getName()+"ok");
});
}
//关闭线程池
service.shutdown();
}
}设置线程池的大小
- CPU 密集型：电脑几核，线程池的数量就设置为几，可以保证CPU的效率最高！
- IO 密集型 ： 判断程序中十分耗IO的线程（线程池中线程的大小可设置为耗IO的线程的两倍）
import java.util.concurrent.*;
public class ThreadPoolDemo {
public static void main(String[] args) {
//自定义线程池
ExecutorService service = new ThreadPoolExecutor(
2,
Runtime.getRuntime().availableProcessors(),
3,
TimeUnit.SECONDS,
new LinkedBlockingDeque<>(3),
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.DiscardOldestPolicy() // 若队列已满，尝试与其它元素竞争，不会抛出异常
);
for (int i = 1; i <= 10; i++) {
service.execute(()->{
System.out.println(Thread.currentThread().getName()+"ok");
});
}
//关闭线程池
service.shutdown();
}
}四大函数式接口（必须掌握）
新时代的程序员：lambda表达式、链式编程、函数式接口、Stream流式计算
函数式接口：只有一个方法的接口
**四大函数式接口：**Consumer, Function, predicate, Supplier
Function函数式接口: 接口中只有一个未实现的方法
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JrZPYNNc-1603071924231)(C:\Users\yxz\AppData\Roaming\Typora\typora-user-images\image-20201013195306468.png)]
import java.util.function.Function;
public class FunctionInterfaceTest {
public static void main(String[] args) {
Function<String,String> function = (str)->{
return str;
};
System.out.println(function.apply("wy"));
}
}Predicate：断定型接口，有一个输入参数，返回值是布尔值
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qZU2WLNB-1603071924232)(C:\Users\yxz\AppData\Roaming\Typora\typora-user-images\image-20201013195228780.png)]
判断字符串是否为空：
public class Demo02 {
public static void main(String[] args) {
// 判断字符串是否为空
// Predicate<String> predicate = new Predicate<String>(){
@Override
public boolean test(String str) {
return str.isEmpty();
}
};
Predicate<String> predicate = (str)->{return str.isEmpty(); };
System.out.println(predicate.test(""));
}
}Consumer：消费型接口
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sgXo8chJ-1603071924234)(C:\Users\yxz\AppData\Roaming\Typora\typora-user-images\image-20201013195534153.png)]
import java.util.function.Consumer;
/**
* Consumer 消费型接口: 只有输入，没有返回值
*/
public class Demo03 {
public static void main(String[] args) {
// Consumer<String> consumer = new Consumer<String>() {
// @Override
// public void accept(String str) {
// System.out.println(str);
// }
// };
Consumer<String> consumer = (str)->{System.out.println(str);};
consumer.accept("sdadasd");
}
}Supplier：供给型接口
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-C7zcuF3Y-1603071924235)(C:\Users\yxz\AppData\Roaming\Typora\typora-user-images\image-20201013195841203.png)]
/**
* Supplier 供给型接口 没有参数，只有返回值
*/
public class Demo04 {
public static void main(String[] args) {
// Supplier supplier = new Supplier<Integer>() {
// @Override
// public Integer get() {
// System.out.println("get()");
// return 1024;
// }
// };
Supplier supplier = ()->{ return 1024; };
System.out.println(supplier.get());
}
}Stream流式计算
题目要求：一分钟内完成此题，只能用一行代码实现！
题目：从6个用户中筛选满足条件的用户
1.ID 必须是偶数
2.年龄必须大于24岁
3.用户名转为大写字母
4.用户名字母倒着排序
5.只输出一个用户
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class StreamDemo {
public static void main(String[] args) {
//定义6个用户
User user1 = new User(1,"a",21);
User user2 = new User(2,"b",22);
User user3 = new User(3,"c",23);
User user4 = new User(4,"d",24);
User user5 = new User(5,"e",25);
User user6 = new User(6,"f",26);
//定义用户列表
List<User> user = Arrays.asList(user1,user2,user3,user4,user5,user6);//数组转化为列表
//Stream负责计算操作
user.stream()
.filter((u)->{return u.getID()%2 == 0;})
.filter((u)->{return u.getAge() > 23;})
.map((u)->{return u.getName().toUpperCase();})
.sorted((u1,u2)->{return u2.compareTo((u1));})
.limit(1)
.forEach(System.out::println);
}
}
class User{
private int ID;
private String name ;
private int age;
public User(int id, String name, int age) {
this.ID = id;
this.name = name;
this.age = age;
}
public int getID() {
return ID;
}
public void setID(int ID) {
this.ID = ID;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}三种方法比较：实现累积求和
import java.util.concurrent.RecursiveTask;
public class ForkJoinDemo extends RecursiveTask<Long> {
private long start;
private long end;
public ForkJoinDemo(long start, long end) {
this.start = start;
this.end = end;
}
@Override
protected Long compute() {
long sum = 0;
long temp = 0;
temp = end - start;
if(temp <= 1000){
for (; start <= end; start++) {
sum = sum + start;
}
return sum;
}
else{
long middle = (start + end) /2;
ForkJoinDemo demo1 = new ForkJoinDemo(start , middle);
demo1.fork(); //拆分任务并压入线程队列
ForkJoinDemo demo2 = new ForkJoinDemo(middle+1 , end);
demo2.fork(); //拆分任务并压入线程队列
return demo1.join() + demo2.join();
}
}
}import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.stream.LongStream;
public class ForkJoinTest {
public static void main(String[] args) throws ExecutionException, InterruptedException {
//方法一
ForkJoinTest.test1(0,1000000000);
//方法二
ForkJoinTest.test2(0,1000000000);
//方法三
ForkJoinTest.test3(0,1000000000);
}
/**
* 普通累积求和方法
* @param start
* @param end
*/
public static void test1(long start,long end){
long startTime = System.currentTimeMillis();
long sum = 0;
for (long i = start; i <= end; i++) {
sum = sum + i;
}
long endTime = System.currentTimeMillis();
System.out.println("执行时间："+ (endTime-startTime) +"------>"+sum);
}
/**
* ForkJoin方法实现累积求和
* @param start
* @param end
*/
public static void test2(long start,long end) throws ExecutionException, InterruptedException {
long startTime = System.currentTimeMillis();
long sum = 0;
ForkJoinPool pool = new ForkJoinPool();
ForkJoinTask<Long> task = new ForkJoinDemo(start,end);
ForkJoinTask<Long> submit = pool.submit(task);
sum = submit.get();
long endTime = System.currentTimeMillis();
System.out.println("执行时间："+ (endTime-startTime) +"------>"+sum);
}
/**
* Stream流计算实现累积求和
* @param start
* @param end
*/
public static void test3(long start,long end){
long startTime = System.currentTimeMillis();
long sum = LongStream.rangeClosed(start,end).parallel().reduce(start,Long::sum);
long endTime = System.currentTimeMillis();
System.out.println("执行时间："+ (endTime-startTime) +"------>"+sum);
}
}异步回调
异步调用：CompletableFuture
1.异步执行
2.成功回调
3.失败回调
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
public class CompletableFutureDemo {
public static void main(String[] args) throws ExecutionException, InterruptedException {
// CompletableFutureDemo.syncRun();
CompletableFutureDemo.syncRunWithValue();
}
/**
* 没有返回值的异步回调---->runAsync
*/
public static void syncRun() throws ExecutionException, InterruptedException {
CompletableFuture<Void> future = CompletableFuture.runAsync(()->{
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
});
System.out.println("线程继续执行");
future.get(); // 阻塞等待结果
}
/**
* 有返回值的异步回调
*/
public static void syncRunWithValue()
{
CompletableFuture<Integer> future = CompletableFuture.supplyAsync(()->{
int i = 10/0;
return 404;
});
try {
System.out.println(future.whenComplete((t,u)->{
System.out.println("正常的返回结果："+t);
System.out.println("错误的返回结果："+u);
}).exceptionally((e)->{
System.out.println(e.getMessage());
return 233;
}).get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}JMM
Volatile
1.保证可见性
2.不保证原子性
3.禁止指令重排
JMM：Java内存模型，是一种约定概念并不真实存在。
1.线程解锁前，必须把共享变量立刻刷回主存。
2.线程加锁前，必须读取主存中的最新值到工作内存中。
3.加锁和解锁是同一把锁
线程、工作内存和主内存关系图
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-D9UYZjKp-1603071924236)(C:\Users\yxz\AppData\Roaming\Typora\typora-user-images\image-20201016210436944.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1sX4hLBF-1603071924238)(C:\Users\yxz\AppData\Roaming\Typora\typora-user-images\image-20201016210517594.png)]
- lock （锁定）：作用于主内存的变量，把一个变量标识为线程独占状态
- unlock （解锁）：作用于主内存的变量，它把一个处于锁定状态的变量释放出来，释放后的变量
才可以被其他线程锁定 - read （读取）：作用于主内存变量，它把一个变量的值从主内存传输到线程的工作内存中，以便
随后的load动作使用 - load （载入）：作用于工作内存的变量，它把read操作从主存中变量放入工作内存中
- use （使用）：作用于工作内存中的变量，它把工作内存中的变量传输给执行引擎，每当虚拟机
遇到一个需要使用到变量的值，就会使用到这个指令 - assign （赋值）：作用于工作内存中的变量，它把一个从执行引擎中接受到的值放入工作内存的变
量副本中 - store （存储）：作用于主内存中的变量，它把一个从工作内存中一个变量的值传送到主内存中，
以便后续的write使用 - write （写入）：作用于主内存中的变量，它把store操作从工作内存中得到的变量的值放入主内
存的变量中
JMM对这八种指令的使用，制定了如下规则:
- 不允许read和load、store和write操作之一单独出现。即使用了read必须load，使用了store必须
write - 不允许线程丢弃他最近的assign操作，即工作变量的数据改变了之后，必须告知主存
- 不允许一个线程将没有assign的数据从工作内存同步回主内存
- 一个新的变量必须在主内存中诞生，不允许工作内存直接使用一个未被初始化的变量。就是怼变量
实施use、store操作之前，必须经过assign和load操作 - 一个变量同一时间只有一个线程能对其进行lock。多次lock后，必须执行相同次数的unlock才能解
锁 - 如果对一个变量进行lock操作，会清空所有工作内存中此变量的值，在执行引擎使用这个变量前，
必须重新load或assign操作初始化变量的值 - 如果一个变量没有被lock，就不能对其进行unlock操作。也不能unlock一个被其他线程锁住的变量
- 对一个变量进行unlock操作之前，必须把此变量同步回主内存
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rxhQQtSp-1603071924239)(C:\Users\yxz\AppData\Roaming\Typora\typora-user-images\image-20201017101023788.png)]
Volatile
保证可见性
import java.util.concurrent.TimeUnit;
public class VolatileDemo {
//不加volatile修饰符，程序会死循环
//加volatile可以保证可见性
public volatile static int num = 0;
public static void main(String[] args) {
new Thread(()->{ //该线程对主内存的变化不清楚
while(num == 0){
}
}).start();
try {
TimeUnit.SECONDS.sleep(2);
num = 1;
System.out.println(num);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}不保证原子性
原子性：操作不可分割
线程A在执行任务的时候，不能被中断，也不能被分割。要么同时成功，要么同时失败。
public class VolatileDemo2 {
//volatile不能保证原子性
private volatile static int num = 0;
public static void main(String[] args) {
for (int i = 1; i <= 20; i++) {
new Thread(()->{
for (int j = 0; j < 1000; j++) {
add();
}
}).start();
}
while(Thread.activeCount() > 2){
Thread.yield();
}
System.out.println(num);
}
public static void add(){
num++;
}
}在不加lock和synchronized的情况下，使用原子类解决原子性问题
import java.util.concurrent.atomic.AtomicInteger;
public class VolatileDemo3 {
//原子类的Integer
private volatile static AtomicInteger num = new AtomicInteger();
public static void main(String[] args) {
for (int i = 1; i <= 20; i++) {
new Thread(()->{
for (int j = 0; j < 1000; j++) {
add();
}
}).start();
}
while (Thread.activeCount() > 2){
Thread.yield();
}
System.out.println(num);
}
public static void add(){
num.getAndIncrement(); //原子类加1操作
}
}指令重排：程序并不是按照写的顺序执行
源代码–>编译器优化的重排–> 指令并行也可能会重排–> 内存系统也会重排—> 执行
处理器在进行指令重排时，考虑数据之间的依赖性
int x = 1; // 1
int y = 2; // 2
x = x + 5; // 3
y = x * x; // 4
我们所期望的：1234 但是可能执行的时候回变成 2134 1324
可不可能是 4123！线程A | 线程B |
x = a | y = b |
b = 1 | a =2 |
正常的结果： x = 0；y = 0；但是可能由于指令重排
线程A | 线程B |
b = 1 | a = 2 |
x =a | y = b |
指令重排导致的诡异结果： x = 2；y = 1；
volatile可以通过内存屏障避免指令重排
作用：
1、保证特定的操作的执行顺序！
2、可以保证某些变量的内存可见性 （利用这些特性volatile实现了可见性）
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-irM2XFHc-1603071924241)(C:\Users\yxz\AppData\Roaming\Typora\typora-user-images\image-20201017112230519.png)]
Volatile 是可以保持 可见性。不能保证原子性，由于内存屏障，可以保证避免指令重排的现象产生！
玩转单列模式
饿汉式
public class Hungry {
private byte[] data1 = new byte[1024*1024];
private byte[] data2 = new byte[1024*1024];
private byte[] data3 = new byte[1024*1024];
private byte[] data4 = new byte[1024*1024];
private Hungry(){
}
private final static Hungry HUNGRY = new Hungry();
private static Hungry getInstance(){
return HUNGRY;
}
}DCL懒汉式
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
public class LazyMan {
private volatile static LazyMan lazyMan;
private static boolean flag = false;
private LazyMan(){
synchronized (LazyMan.class){
if(flag == false){
flag = true;
}
else{
throw new RuntimeException("不要试图使用反射破坏异常");
}
}
}
public static LazyMan getInstance(){
if(lazyMan == null){
synchronized (LazyMan.class){
if(lazyMan == null){
lazyMan = new LazyMan(); //并不是一个原子性的操作
}
}
}
return lazyMan;
}
public static void main(String[] args) throws Exception {
// LazyMan instance1 = LazyMan.getInstance();
//使用反射
Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
declaredConstructor.setAccessible(true);
LazyMan instance1 = declaredConstructor.newInstance();
Field flag = LazyMan.class.getDeclaredField("flag");
flag.setAccessible(true);
flag.set(instance1,false);
LazyMan instance2 = declaredConstructor.newInstance();
System.out.println(instance1);
System.out.println(instance2);
}
}静态内部类: 单例模式
import javax.xml.ws.Holder;
public class StaticInnerClassDemo {
private StaticInnerClassDemo(){
}
public static StaticInnerClassDemo getInstance(){
return InnerClass.demo;
}
public static class InnerClass{
private static final StaticInnerClassDemo demo = new StaticInnerClassDemo();
}
}可以使用反射机制验证单例模式的不安全
枚举
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
public enum EnumDemo {
INSTANCE;
public EnumDemo getInstance(){
return INSTANCE;
}
}
class Test {
public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
EnumDemo instance1 = EnumDemo.INSTANCE;
Constructor<EnumDemo> demo = EnumDemo.class.getDeclaredConstructor(String.class,int.class);
demo.setAccessible(true);
EnumDemo instance2 = demo.newInstance();
System.out.println(instance1);
System.out.println(instance2);
//抛出异常：Cannot reflectively create enum objects
}
}[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-y9U37BeW-1603071924242)(C:\Users\yxz\AppData\Roaming\Typora\typora-user-images\image-20201017155724540.png)]
反编译：jad -sjava EnumDemo.class 编译成java文件
深入理解CAS
CAS：只有设置的预期值达到了，才会去执行下面的操作
import java.util.concurrent.atomic.AtomicInteger;
public class CASDemo {
public static void main(String[] args) {
AtomicInteger atomic = new AtomicInteger(2020);
System.out.println(atomic.compareAndSet(2020,2021));
System.out.println(atomic.get());
atomic.getAndIncrement();
System.out.println(atomic.compareAndSet(2020,2021));
System.out.println(atomic.get());
}
}Unsafe类
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ANtzFdtF-1603071924244)(C:\Users\yxz\AppData\Roaming\Typora\typora-user-images\image-20201018090550488.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0NakgJ3X-1603071924245)(C:\Users\yxz\AppData\Roaming\Typora\typora-user-images\image-20201018091538715.png)]
CAS ： 比较当前工作内存中的值和主内存中的值，如果这个值是期望的，那么则执行操作！如果不是就
一直循环！缺点：
1、 循环会耗时
2、一次性只能保证一个共享变量的原子性
3、ABA问题CAS：ABA问题（狸猫换太子）
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-c1EiEcf1-1603071924246)(C:\Users\yxz\AppData\Roaming\Typora\typora-user-images\image-20201018092133048.png)]
import java.util.concurrent.atomic.AtomicInteger;
public class CASDemo1 {
public static void main(String[] args) {
AtomicInteger atomic = new AtomicInteger(2020);
//捣乱线程
System.out.println(atomic.compareAndSet(2020,2022));
System.out.println(atomic.compareAndSet(2022,2020));
//期望线程
System.out.println(atomic.compareAndSet(2020,6666));
}
}原子引用，解决CAS中的ABA问题
带有版本号的原子操作：
import java.sql.SQLOutput;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicStampedReference;
public class CASABADemo {
static AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(1,1);
public static void main(String[] args) {
new Thread(()->{
int stamp = atomicStampedReference.getStamp();//获得版本号
System.out.println("版本号1：" + stamp);
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(atomicStampedReference.compareAndSet(1, 2, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1));
System.out.println("版本号2："+atomicStampedReference.getStamp());
System.out.println(atomicStampedReference.compareAndSet(2, 1, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1));
System.out.println("版本号3："+atomicStampedReference.getStamp());
}).start();
new Thread(()->{
int stamp = atomicStampedReference.getStamp();//获得版本号
System.out.println("版本号4："+atomicStampedReference.getStamp());
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(atomicStampedReference.compareAndSet(1,6,stamp,stamp+1));
System.out.println("版本号5："+atomicStampedReference.getStamp());
}).start();
}
}各种锁的理解
公平锁和非公平锁
公平锁： 非常公平， 不能够插队，必须先来后到！
非公平锁：非常不公平，可以插队 （默认都是非公平）
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UMlvShAU-1603071924247)(C:\Users\yxz\AppData\Roaming\Typora\typora-user-images\image-20201018100959355.png)]
可重入锁（递归锁）
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0Pe2k6QW-1603071924249)(C:\Users\yxz\AppData\Roaming\Typora\typora-user-images\image-20201018101042685.png)]
Synchronized和Lock都可以实现可重入锁:
import java.sql.SQLOutput;
public class SynReenLock {
public static void main(String[] args) {
Phone phone = new Phone();
new Thread(()->{
phone.SMS();
},"A").start();
new Thread(()->{
phone.SMS();
},"B").start();
}
}
class Phone{
public synchronized void SMS(){
System.out.println(Thread.currentThread().getName() + "正在发信息中");
call();
}
public synchronized void call(){
System.out.println(Thread.currentThread().getName() + "正在打电话中");
}
}自旋锁
自定义自旋锁：
import java.util.concurrent.TimeUnit;
public class SpinLockTest {
public static void main(String[] args) {
SpinLockDemo spinLockDemo = new SpinLockDemo();
new Thread(()->{
spinLockDemo.myLock();
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
finally {
spinLockDemo.unLock();
}
},"A").start();
new Thread(()->{
spinLockDemo.myLock();
try{
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
finally {
spinLockDemo.unLock();
}
},"B").start();
}
}死锁
import java.util.concurrent.TimeUnit;
public class DeadLockDemo {
public static void main(String[] args) {
String lockA = "lockA";
String lockB = "lockB";
new Thread(new DeadThread(lockA,lockB),"T1").start();
new Thread(new DeadThread(lockB,lockA),"T2").start();
}
}
class DeadThread implements Runnable{
private String lockA;
private String lockB;
public DeadThread(String lockA, String lockB) {
this.lockA = lockA;
this.lockB = lockB;
}
@Override
public void run() {
synchronized (lockA){
System.out.println(Thread.currentThread().getName()+"获得锁："+lockA+"----想要获得锁："+lockB);
try {
TimeUnit.SECONDS.sleep(6);
} catch (InterruptedException e){
e.printStackTrace();
}
synchronized (lockB){
System.out.println(Thread.currentThread().getName()+"获得锁："+lockB);
}
}
}
}使用jps -l 定位进程号
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jRCQh1Qj-1603071924251)(C:\Users\yxz\AppData\Roaming\Typora\typora-user-images\image-20201019094118682.png)]
使用jstack 进程号找到死锁问题
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-P8jZJGJf-1603071924252)(C:\Users\yxz\AppData\Roaming\Typora\typora-user-images\image-20201019094253905.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oHFytdi9-1603071924253)(C:\Users\yxz\AppData\Roaming\Typora\typora-user-images\image-20201019094319706.png)]
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
