文章目录

  • 线程终止
    • 基本说明
    • 案例
  • 线程常用方法1
    • 细节
  • 线程常用方法2
    • 礼让（yield）
    • 插队（join）
      • 案例
  • 线程常用方法3
    • 用户线程和守护线程
      • 用户线程
      • 守护线程
      • 常见的守护线程（垃圾回收机制）
        • 案例
  • 线程的生命周期（重点）
    • 1.NEW
    • 2.RUNNABLE（Ready - Running）
    • 3.BLOCKED
    • 4.WAITIN
    • 5.TIMED WAITING
    • 6.TERMINATED
      • 案例演示
  • Synchronized（底层较为复杂）
    • 线程同步机制
    • 同步具体方法
  • 互斥锁
    • 基本介绍
    • 同步代码块
    • 注意事项和细节(注意this)
  • 线程的死锁
    • 基本介绍
    • 应用案例
  • 释放锁
    • 下面操作会释放锁
    • 下面操作不会释放锁
  • 课后作业（1）
  • 课后作业2

线程终止

基本说明

  1. 当线程完成任务后，会自动退出。

  2. 还可以通过使用变量来控制run方法退出的方式停止线程，即通知方式

案例

  • 启动一个线程t，要求在main线程中去停止线程t，请编程实现。
package com.tao.exit_;/*** Create By 刘鸿涛* 2022/1/15 5:16*/
public class Homework03 {public static void main(String[] args) throws InterruptedException {Test test = new Test();test.start();//让main跑起来
//        Homework03 homework03 = new Homework03();
//        homework03.start();
//        int count = 0;
//        while(true){//            System.out.println("main线程执行中....." + (++count));
//
//            try{//                Thread.sleep(500);
//            }catch(InterruptedException e){//                e.printStackTrace();
//            }
//            if(count == 20){//                test.setCheck(false);
//                System.out.println("AThread线程死亡...");
//            }
//        }System.out.println("主线程休眠10秒");Thread.sleep(10000);test.setCheck(false);System.out.println("AThread线程死亡");}
}
class Test extends Thread{int count = 0;//设置一个控制变量private boolean check = true;public void setCheck(boolean check) {this.check = check;}@Overridepublic void run(){while(check){try{Thread.sleep(500);}catch(InterruptedException e){e.printStackTrace();}System.out.println("AThread线程执行中..." + (++count));}}
}

线程常用方法1

  1. setName //设置线程名称，使之与参数 name 相同
  2. getName //返回该线程的名称
  3. start //使该线程开始执行；Java虚拟机底层调用该线程的 start（）方法
  4. run //调用线程对象 run 方法
  5. setPriority //更改线程的优先级
  6. getPriority //获取线程的优先级
  7. sleep //在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）
  8. interrupt //中断线程

细节

  1. start 底层会创建新的线程，调用run，run就是一个简单的方法调用，不会启动新线程
  2. 线程优先级的范围
  3. interrupt，中断线程，但并没有真正的结束线程。所以一般用于中断正在休眠线程
  4. sleep：线程的静态方法，使当前线程休眠
package com.tao.exit_;/*** Create By 刘鸿涛* 2022/1/15 7:51*/
public class threadmethod {public static void main(String[] args) throws InterruptedException {Test02 test02 = new Test02();test02.start();test02.setPriority(1);  //更改线程优先级为1for (int i = 0; i < 5;) {Thread.sleep(1000);System.out.println("提醒" + (++i) + "秒");}System.out.println(test02.getName() + "线程优先级 = " + test02.getPriority());   //1test02.interrupt(); //唤醒线程}
}
class Test02 extends Thread{@Overridepublic void run(){while(true){for (int i = 0; i < 20; ) {System.out.println("涛涛在吃第" + (++i) + "包子");}try{System.out.println(Thread.currentThread().getName() + "休眠中...");Thread.sleep(10000);}catch(InterruptedException e){System.out.println(Thread.currentThread().getName() + "的休眠被中断了！（interrupt）");
//                e.printStackTrace();}}}
}

线程常用方法2

礼让（yield）

yield：线程的礼让。让出cpu，让其他线程执行，但礼让的时间不确定，所以也不一定礼让成功

                test02.yield(); //礼让，不一定成功，如果线程够用就不会成功，如果线程繁忙就会礼让成功

而yield（）线程礼让，是根据线程繁忙程度来判断是否需要礼让，比如我们网上售票系统，剩下最后一张票的时候，如果没有礼让机制，那最后一张票很可能同时被多个人购买

插队（join）

join：线程的插队。插队的线程一旦插队成功，则肯定先执行完插入的一个线程所有的任务

package com.tao.exit_;/*** Create By 刘鸿涛* 2022/1/15 7:51*/
public class threadmethod {public static void main(String[] args) throws InterruptedException {Test02 test02 = new Test02();test02.start();
//        test02.setPriority(1);  //更改线程优先级为1for (int i = 0; i < 10;) {Thread.sleep(1000);System.out.println("提醒" + (++i) + "秒" + Thread.currentThread().getName());if (i == 5){test02.join();}}}
}
class Test02 extends Thread{int i = 0;@Overridepublic void run(){while(true){System.out.println("涛涛在吃第" + (++i) + "包子" + Thread.currentThread().getName());try{//                System.out.println(Thread.currentThread().getName() + "休眠中...");Thread.sleep(1000);}catch(InterruptedException e){e.printStackTrace();}if (i == 10){break;}}}
}

案例

  • 创建一个子进程，每隔1s 输出 hello，输出20次， 主线程每隔1秒，输出hi，输出20次，要求：两个线程同时执行，当主线程输出5次后，就让子线程运行完毕，主线程再继续，

线程常用方法3

用户线程和守护线程

用户线程

  • 也叫做工作线程，当线程的任务执行完或通知方式结束

守护线程

  • 一般是为工作线程服务的，当所有的用户线程结束，守护线程自动结束

常见的守护线程（垃圾回收机制）

案例

package com.tao.method;/*** Create By 刘鸿涛* 2022/1/16 6:21*/
public class ThreadMethod03 {public static void main(String[] args) throws InterruptedException {A a = new A();//目的，当main线程退出后，子线程也退出a.setDaemon(true);  //设置线程守护，此线程结束后，守护线程同时结束a.start();  //开始执行子线程for (int i = 1; i < 11; i++) {System.out.println(Thread.currentThread().getName() + "宝强在外地工作..." + i);Thread.sleep(1000);}Thread.sleep(3000);System.out.println("宝强到家了..");}
}
class A extends Thread{@Overridepublic void run(){while(true){System.out.println("马蓉和宋喆在愉快的聊天...");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}}
}

线程的生命周期（重点）

JDK中用Thread.State枚举表示了线程的几种状态

线程状态，线程可以处于以下状态之一；

1.NEW

尚未启动的线程处于以下状态之一；

2.RUNNABLE（Ready - Running）

在JAVA虚拟机中执行的线程处于此状态

3.BLOCKED

被阻塞等待监视器锁定的线程处于此状态

4.WAITIN

正在等待另一个线程执行特定动作的线程处于此状态

5.TIMED WAITING

正在等待另一个线程执行动作达到指定等待时间的线程处于此状态

6.TERMINATED

已退出的线程处于此状态

案例演示

package com.tao.state_;/*** Create By 刘鸿涛* 2022/1/16 7:27*/
public class ThreadState_ {public static void main(String[] args) throws InterruptedException {T t = new T();System.out.println(t.getName() + "状态" + t.getState());t.start();while (Thread.State.TERMINATED != t.getState()){System.out.println(t.getName() + " 状态 " + t.getState());Thread.sleep(500);}System.out.println(t.getName() + " 状态 " + t.getState());}
}class T extends Thread {@Overridepublic void run(){for (int i = 0; i < 10; i++) {System.out.println("hi " + i);try {Thread.sleep(1000);}catch(InterruptedException e){e.printStackTrace();}}}
}

Thread-0状态NEW
Thread-0 状态 RUNNABLE
hi 0
Thread-0 状态 TIMED_WAITING
hi 1
Thread-0 状态 TIMED_WAITING
Thread-0 状态 TIMED_WAITING
hi 2
Thread-0 状态 TIMED_WAITING
Thread-0 状态 TIMED_WAITING
hi 3
Thread-0 状态 RUNNABLE
Thread-0 状态 TIMED_WAITING
hi 4
Thread-0 状态 RUNNABLE
Thread-0 状态 TIMED_WAITING
Thread-0 状态 RUNNABLE
hi 5
Thread-0 状态 TIMED_WAITING
hi 6
Thread-0 状态 RUNNABLE
Thread-0 状态 TIMED_WAITING
hi 7
Thread-0 状态 TIMED_WAITING
Thread-0 状态 TIMED_WAITING
hi 8
Thread-0 状态 TIMED_WAITING
Thread-0 状态 TIMED_WAITING
hi 9
Thread-0 状态 TIMED_WAITING
Thread-0 状态 TIMED_WAITING
Thread-0 状态 TERMINATED

Process finished with exit code 0

Synchronized（底层较为复杂）

线程同步机制

  1. 在多线程编程，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问技术，保证数据在任何同一时刻，最多有一个线程访问，以保证数据的完整性

  2. 也可以这样理解：线程同步，即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作，其他线程才能对该内存地址进行操作

同步具体方法

  1. 同步代码块
synchronized(对象){ //得到对象的锁，才能操作同步代码//需要被同步代码；
}
  1. synchronized还可以放在方法声明中，表示整个方法 - 为同步方法
public synchronized void m(String name){//需要被同步的代码
}
  1. 如何理解

就好像某个小伙伴上厕所前先把门关上（上锁），完事后再出来（解锁），那么其他小伙伴就可在使用厕所了，如图：

  1. 使用synchronized解决售票问题
package com.tao.ticket;/*** Create By 刘鸿涛* 2022/1/15 4:45*/
public class SellTicket {public static void main(String[] args) {//继承Thread
//        SellTicket01 sellTicket01 = new SellTicket01();
//        SellTicket01 sellTicket02 = new SellTicket01();
//        SellTicket01 sellTicket03 = new SellTicket01();
//        sellTicket01.start();   //启动售票线程
//        sellTicket02.start();   //启动售票线程
//        sellTicket03.start();   //启动售票线程//实现Runnable接口
//        SellTicket02 sellTicket02 = new SellTicket02();
//        SellTicket02 sellTicket021 = new SellTicket02();
//        SellTicket02 sellTicket022 = new SellTicket02();
//        Thread thread = new Thread(sellTicket02);
//        Thread thread1 = new Thread(sellTicket021);
//        Thread thread2 = new Thread(sellTicket022);
//        thread.start();
//        thread1.start();
//        thread2.start();//        SellTicket02 sellTicket02 = new SellTicket02();
//        new Thread(sellTicket02).start();
//        new Thread(sellTicket02).start();
//        new Thread(sellTicket02).start();//sell()方法SellTicket03 sellTicket03 = new SellTicket03();new Thread(sellTicket03).start();new Thread(sellTicket03).start();new Thread(sellTicket03).start();
//        new Thread(sellTicket031).start();          //error,超卖，原因不明
//        new Thread(sellTicket032).start();        //error，超卖，原因不明}
}class SellTicket01 extends Thread {private static int ticketNum = 100; //@Overridepublic void run() {while (true) {if (ticketNum <= 0) {System.out.println("售票结束");break;}try {Thread.sleep(50);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("窗口 " + Thread.currentThread().getName() + "卖出了一张票" + "\n剩余票数：" + (--ticketNum));}}
}//实现接口方式，使用synchronized实现线程同步
class SellTicket02 implements Runnable {private static int ticketNum = 100; //@Overridepublic synchronized void run() { //同步方法，在同一时刻，只能有一个线程来执行run方法while (true) {if (ticketNum <= 0) {System.out.println("售票结束");break;}try {Thread.sleep(50);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("窗口 " + Thread.currentThread().getName() + "卖出了一张票" + "\n剩余票数：" + (--ticketNum));}}
}class SellTicket03 implements Runnable {private static int ticketNum = 100; //private boolean loop = true;public synchronized void sell() {if (ticketNum <= 0) {System.out.println("售票结束");loop = false;return;}try {Thread.sleep(50);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("窗口 " + Thread.currentThread().getName() + "卖出了一张票" + "\n剩余票数：" + (--ticketNum));}@Overridepublic void run() { //同步方法，在同一时刻，只能有一个线程来执行run方法while (loop) {sell();}}
}

互斥锁

基本介绍

  1. Java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性。
  2. 每个对象都对应一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象。
  3. 关键字synchronized 来与对象的互斥锁联系。当某个对象用synchronized修饰时，表明该对象在任一时刻只能由一个线程访问
  4. 同步的局限性：导致程序的执行效率要降低
  5. 同步方法（非静态的）的锁可以使this，也可以是其他对象（要求是同一个对象）
  6. 同步方法（静态的）的锁为当前类本身

同步代码块

class SellTicket03 implements Runnable {private static int ticketNum = 100; //private boolean loop = true;Object object = new Object();//同步方法（静态的）的锁为当前类本身//1. public synchronized static void m1(){}  锁是加在SellTicket03.class里public synchronized static void m1(){}//举例public static void m2(){synchronized (SellTicket03.class) {     //静态方法为，类本身System.out.println("m2");}}public /*synchronized*/ void sell() {//1.public synchronized void sell(){}//2.这时锁在 this对象//3.也可以在代码块上写 synchronize ，同步代码块，互斥锁在this对象//同步代码块synchronized (/*this*/ object) {if (ticketNum <= 0) {System.out.println("售票结束");loop = false;return;}try {Thread.sleep(50);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("窗口 " + Thread.currentThread().getName() + "卖出了一张票" + "\n剩余票数：" + (--ticketNum));}}@Overridepublic void run() { //同步方法，在同一时刻，只能有一个线程来执行run方法while (loop) {sell();}}
}

注意事项和细节(注意this)

  1. 同步方法如果没有使用static修饰：默认锁对象为this
  2. 如果方法使用static修饰，默认锁对象：当前类.class
  3. 实现的落地步骤：
  • 需要先分析上锁的代码
  • 选择同步代码块或同步方法
  • 要求多个线程的锁对象为同一个即可！(同一个对象)

线程的死锁

基本介绍

  • 多个线程都占用了对方的锁资源，但不肯想让，导致了死锁，在编程是一定要避免死锁的发生

应用案例

  • 妈妈：你先完成作业，才让你玩手机
  • 小明：你先让我玩手机，我才完成作业
package com.tao.syn;/*** Create By 刘鸿涛* 2022/1/16 9:28*/
public class DeadLock_ {public static void main(String[] args) {//模拟死锁现象DeadLockDemo A = new DeadLockDemo(true);DeadLockDemo B = new DeadLockDemo(false);A.start();B.start();}
}//线程
class DeadLockDemo extends Thread {static Object o1 = new Object();    //保证多线程，共享一个对象，这里使用staticstatic Object o2 = new Object();boolean flag;public DeadLockDemo(boolean flag){this.flag = flag;}public void run(){//下面业务逻辑的分析//1.如果flag为 T，线程A 就会先得到/持有 o1 对象锁，然后尝试去获取 o2 对象的锁//2.如果线程A 得不到 o2 对象锁，就会Blocked//3.如果flag为 F，线程B 就会先得到/持有 o2 对象锁，然后尝试去获取o1 对象的锁//4.如果线程B 得不到 o1 对象锁，就会Blockedif(flag){synchronized (o1){System.out.println(Thread.currentThread().getName() + "A线程进入1");synchronized (o2){System.out.println(Thread.currentThread().getName() + "进入2");}}}else{synchronized (o2){System.out.println(Thread.currentThread().getName() + "B线程进入2");synchronized (o1){System.out.println(Thread.currentThread().getName() + "进入1");}}}}
}
  • 卡死

释放锁

下面操作会释放锁

  1. 当前线程的同步方法、同步代码块执行结束
  • 案例：上厕所，完事出来
  1. 当前线程在同步代码块，同步方法中遇到break，return
  • 案例：没有正常的完事，经理叫他修改bug，不得已出来
  1. 当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束
  • 案例：没有正常的完事，发现忘带纸，不得已出来
  1. 当前线程在同步代码块、同步方法中执行了线程对象的wait（）方法，当前程序暂停，并释放锁。
  • 案例：没有正常完事，觉得需要酝酿下，所以出来等会再进去

下面操作不会释放锁

  1. 线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行，不会释放锁
  • 案例：上厕所，太困了，在坑位上迷了一会
  1. 线程执行同步代码块时，其他线程调用了该线程的suspend（）方法将该线程挂起，该线程不会释放锁。

提示：应尽量避免使用suspend（）和resume（）来控制线程，这两个方法不再推荐使用

课后作业（1）

1.在main方法中启动两个线程
2. 第一个线程循环随机打印100以内的整数
3. 直到第2个线程从键盘读取了“Q”命令

package com.tao.homeowrk;import java.util.Scanner;/*** Create By 刘鸿涛* 2022/1/17 2:50*/
public class Homework01 {public static void main(String[] args) {A a = new A();          //A线程启动,需要对象名a.start();new B(a).start();        //B线程启动，匿名对象}
}class A extends Thread {private boolean loop = true;public void setLoop(boolean loop) {this.loop = loop;}@Overridepublic void run() {while (loop) {System.out.println("A线程" + (int) (Math.random() * 100 + 1));try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}}
}class B extends Thread {private Scanner sc = new Scanner(System.in);private A a;public B(A a) {this.a = a;}@SuppressWarnings({"all"})@Overridepublic void run() {while (true) {System.out.println("B线程" + "请输入字母");char input = sc.next().toUpperCase().charAt(0);if (input == 'Q') {a.setLoop(false);System.out.println("A线程终止");}}}
}
//    @Override
//    public void keyTyped(KeyEvent e) {//
//    }
//
//    @SuppressWarnings({"all"})
//    @Override
//    public void keyPressed(KeyEvent e) {//        if (e.getKeyCode() == KeyEvent.VK_Q) {//            a.setLoop(false);
//            System.out.println("A线程终止");
//        }
//    }
//
//    @Override
//    public void keyReleased(KeyEvent e) {//
//    }

课后作业2

  1. 有两个用户分别从同一个卡上取钱（总额：10000）
  2. 每次都取1000，当余额不足时，就不能取款了
  3. 不能出现超取现象 => 线程同步问题。
package com.tao.homeowrk;/*** Create By 刘鸿涛* 2022/1/17 3:47*/
public class Homework02 {public static void main(String[] args) {C c = new C();Thread thread = new Thread(c);Thread thread1 = new Thread(c);thread.setName("t1");thread1.setName("t2");thread.start();thread1.start();}
}class C implements Runnable {private int total = 10000;@Overridepublic void run() {while (true) {//1.这是使用了 synchronized 实现了线程同步//2.当多个线程执行到这里时，就会去争夺 this对象锁//3.哪个线程争夺到（获取）this对象锁，就执行synchronized代码块//4.争夺不到this对象锁，就blocked，准备继续争夺synchronized (this) {       //thjs对象锁，是非公平锁if (total <= 999) {System.out.println("余额不足");break;}System.out.println(Thread.currentThread().getName() + "取了1000块，\n还剩下" + (total -= 1000));}try {Thread.sleep(500);} catch (InterruptedException e) {e.printStackTrace();}}}
}

Java基础 - 坦克大战（第四章，线程基础）相关推荐

  1. JAVA之坦克大战（四）敌方坦克的移动和发射子弹

    思路:敌方坦克移动和发射子弹肯定需要单独的线程,然后敌方坦克的随机移动需要获取四个随机的方向做到以上几点之后会发现做出来的敌方坦克非常的鬼畜,原因是获取随机的方向太频繁,所以我写了一个for循环控制1 ...

  2. Python基础——PyCharm版本——第四章、基础语法-分支语句(条件判断if语句)

  3. 计算机基础知识第四章测试,第四章计算机基础知识.ppt

    第四章计算机基础知识.ppt 第四章 计算机基础知识 一.Word的启动与退出 (1)从"开始"菜单启动.选择"开始"→"程序"→" ...

  4. 《Java小游戏实现》：坦克大战(续四)

    <Java小游戏实现>:坦克大战(续四) 相关博文: <Java小游戏实现>:坦克大战http://blog.csdn.net/u010412719/article/detai ...

  5. Java基础学习——第十四章 网络编程

    Java基础学习--第十四章 网络编程 一.网络编程概述 计算机网络: 把分布在不同地理区域的计算机与专门的外部设备用通信线路互连成一个规模大.功能强的网络系统,从而使众多的计算机可以方便地互相传递信 ...

  6. （Java高级教程）第四章必备前端基础知识-第二节1：CSS概述和选择器

    文章目录 一:CSS概述 (1)概述 (2)语法规范 (3)CSS引入方式 二:选择器 (1)基础选择器 ①:标签选择器 ②:类选择器 ③:id选择器 ④:通配符选择器 总结 (2)复合选择器 ①:后 ...

  7. java怎么连发子弹_【Java_项目篇1】--JAVA实现坦克大战游戏--子弹连发+爆炸效果（四）...

    前期相关文章 [Java_项目篇<1>]–JAVA实现坦克大战游戏–画出坦克(一) [Java_项目篇<1>]–JAVA实现坦克大战游戏–坦克移动+添加敌方坦克(二) [Jav ...

  8. java坦克大战登录界面设计_基于JAVA的坦克大战设计和实现-代码.doc

    JISHOU UNIVERSITY 本科生毕业设计 题 目:基于JAVA的坦克大战设计与实现作 者:学 号:所属学院:专业年级:指导教师:职 称:完成时间:2012年5月7日 吉首大学 基于JAVA的 ...

  9. java小组坦克大战游戏开发文档开发日志_java实现坦克大战游戏

    本文实例为大家分享了java实现坦克大战游戏的具体代码,供大家参考,具体内容如下 一.实现的功能 1.游戏玩法介绍 2.自定义游戏(选择游戏难度.关卡等) 3.自定义玩家姓名 4.数据的动态显示 二. ...

  10. Java实现坦克大战，单机版和联网版

    Java实现坦克大战 源码获取途径 部分源代码 源码获取途径 百度网盘链接: 百度网盘地址 提取码:5r7i GitHub Github获取地址 部分源代码 public class TankClie ...

最新文章

  1. lucene.net mysql_用Lucene[1].net对数据库建立索引及搜索+
  2. activity的四种加载模式
  3. Google将如何改变你观看电视的习惯
  4. 手工雕刻图纸_龙门整体铝板雕刻弧形楼梯护栏实力商家
  5. 利用状态图实现词法分析
  6. Google Bigtable
  7. 游戏组件——挑战：创建NextBlock游戏组件
  8. 彻底禁用chrome请停用以开发者模式运行的扩展程序弹框
  9. 团队管理---优秀管理者必须掌握的“七大秘诀”
  10. 【kafka】kafka topic Dump log
  11. Android程序开发学习之创建第一个Android程序（Hello World程序）
  12. matlab拟合例子,MATLAB数据拟合例子
  13. PostMan 调用 Auth2.0 获取Token 报错问题总结
  14. 打印纸张尺寸换算_常用纸张的尺寸大小对照表-纸张规格对照表.doc
  15. thinkpadt410接口介绍_thinkpadt410价格与评测介绍【图文】
  16. 新个税来了！一图看清你能省多少钱，转需！ ​​​​
  17. Python分支语句练习题
  18. 「学习笔记」黑马面面布局开发
  19. 二次型的标准型、规范型
  20. 淘宝静态页面html+css部分

热门文章

  1. 一个复杂的“预算”模板设计
  2. oracle数据泵导出 不全,Oracle RAC数据泵导出问题处理
  3. 将首地址为MEM的100个字的数组中所有为0的项删除 ;并将后续项向前压缩，最后将数组剩余部分补上0。方法2！！！
  4. 使用APICloud 科大讯飞SDK快速实现语音识别功能
  5. Qt录音+百度语音Linux C++ SDK识别包实现语音识别
  6. [人脸对齐] Attention-Driven Cropping for Very High Resolution Facial Landmark Detection
  7. Centos 各版本系统ISO镜像下载地址
  8. thinkphp5的消息队列详细教程
  9. KD500全自动电容电感测试仪
  10. element 下拉菜单el-dropdown如何更改样式？