Java进阶——多线程基础

news2024/9/22 15:51:55

文章目录

  • 线程基础
    • 1、线程介绍
      • 1.1、线程相关概念
    • 2、线程基本使用
      • 创建线程的两种方式：
        • 2.1、 继承Thread 类，重写run方法
        • 2.2、实现Runnable接口，重写run方法
        • 2.3、多线程的简单演示：
        • 2.4、继承Thread 和实现Runnable 的区别
        • 2.5、线程终止
    • 3、线程方法
      • 3.1、线程常用的方法一：
      • 3.2、线程的常用方法二：
      • 3.3、用户线程和守护线程
    • 4、线程生命周期
    • 5、Synchronized
    • 6、互斥锁
    • 7、死锁
      • 释放锁

线程基础

1、线程介绍

1.1、线程相关概念

  • 程序（program）：是完成特定任务，用某种语言编写的一组的集合（例如：java代码就是一个程序）
  • 进程：是指运行中的程序（比如：我现在使用的Typora）
    • 进程是程序的一次执行过程
    • 是动态的过程：由他自身的产生、存在和消亡的过程
  • 什么是线程？
    • 线程是由进程创建的，是进程的一个实体
    • 一个进程可以拥有多个线程
  • 其他概念
    • 单线程：同一时刻，只允许执行一个线程
    • 多线程：同一时刻，可以执行多个线程
    • 并发：同一时刻，多个任务交替执行（单CPU实现多任务就是并发）
    • 并行：同一时刻，多个任务同时执行（多核CPU可以实现并行）

2、线程基本使用

创建线程的两种方式：

2.1、 继承Thread 类，重写run方法

线程应用案例1——继承Thread类：

/**
 * @author java小豪
 * @version 1.0.0
 * @date 2022/12/3
 * @description 实体类
 * <p>
 *    1.当一个类继承 Thread类， 该类就可以当做线程使用
 *    2.我们会重写run方法，写上自己的业务代码
 *    3.run Thread 类实现了 Runnable 接口的run方法
 *     public void run() {
 *         if (target != null) {
 *             target.run();
 *         }
 *     }
 * </p>
 */
public class Cat extends Thread{
    int times = 0;
    @Override
    public void run() {
        while(true) {
            // 每隔1秒，在控制台输出“喵喵,我是小猫咪"
            System.out.println("喵喵，我是小喵咪" + (++times) + "线程名=" + Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 当times输出8次是我们就退出线程
            if (times == 80) {
                break;
            }
        }
    }
}

/**
 * @author java小豪
 * @version 1.0.0
 * @date 2022/12/3
 * @description 线程的基本使用
 */
public class Thread01{
    public static void main(String[] args) throws InterruptedException {
        // 创建一个Cat对象,当线程使用
        Cat cat = new Cat();
        // 启动线程
        cat.start();
        // 当main线程启动一个子线程 Thread-0，主线程不会阻塞，会继续执行
        // 主线程和子线程是交替执行的
        System.out.println("主线程继续执行" + Thread.currentThread().getName());
        for (int i = 0; i < 60; i++) {
            System.out.println("主线程 i = " + i);
            // 让主线成休眠
            Thread.sleep(1000);
        }
    }
}

启动线程为什么是start：

启动线程最终会执行cat的run方法，而cat.run()方法就是一个普通的方法，并没有真正的启动多线程，run执行完毕后才会向下执行

image-20221203101824177

我们可以追踪下源码进行分析

image-20221203102458667

image-20221203102447530

2.2、实现Runnable接口，重写run方法

线程应用案例2——实现Runnable接口：

/**
 * @author java小豪
 * @version 1.0.0
 * @date 2022/12/3
 * @description 通过实现Runnable接口， 开发线程类
 */
public class Dog implements Runnable{

    int count = 0;
    @Override
    public void run() {
        while (true) {
            System.out.println("Hello World!" + (++count) + Thread.currentThread().getName());

            // 休眠1秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count == 10) {
                break;
            }
        }
    }
}

public class Thread02 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        // 这里不能调用start dog.start();
        Thread thread = new Thread(dog);
        thread.start();
    }
}

在Thread thread = new Thread(dog);中使用到了一种设计模式：静态代理模式

在Thread类里面有个私有属性：==private Runnable target;==当我们实现Runnable接口的run方法时会调用如下的方法，

当我们Thread thread = new Thread(dog);时，因为Dog实现了Runnable接口，所以这里的dog就相当于时target

个人理解：如有不对的地方请批评指正

@Override
public void run() {
  if (target != null) {
    target.run();
  }
}

2.3、多线程的简单演示：

/**
 * @author java小豪
 * @version 1.0.0
 * @date 2022/12/3
 * @description 在main线程启动两个子线程
 */
public class Thread03 {
    public static void main(String[] args) {
        T1 t1 = new T1();
        T2 t2 = new T2();
        Thread thread1 = new Thread(t1);
        Thread thread2 = new Thread(t2);
        thread1.start();
        thread2.start();
    }
}

class T1 implements Runnable{
    int count = 0;
    @Override
    public void run() {
        while (true){
            // 给隔1秒输出”hello world!" 输出10次
            System.out.println("Hello World!" + (++count));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count == 10) {
                break;
            }
        }
    }
}

class T2 implements Runnable {
    int count = 0;
    @Override
    public void run() {
        while (true){
            // 给隔1秒输出”hello world!" 输出10次
            System.out.println("Hello" + (++count));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count == 5) {
                break;
            }
        }
    }
}

子线程的理解：

image-20221203130658810

2.4、继承Thread 和实现Runnable 的区别

  • 从java设计角度看，通过继承Thread和实现Runnable接口来创建线程本质上没有区别
  • 实现Runnable接口方式更加适合多个线程共享一个资源的情况，避免了单继承的限制
  • 建议使用Runnable接口的方式开启线程。

2.5、线程终止

  • 当线程完成任务后，会自动退出
  • 还可以通过使用变量来控制run方法退出的方式进行停止线程，即通知方式

线程终止演示：

/**
 * @author java小豪
 * @version 1.0.0
 * @date 2022/12/3
 * @description 线程的退出
 */
public class ThreadEit_ {
    public static void main(String[] args) throws InterruptedException {
        Th th = new Th();
        th.start();

        // main线程去控制th线程的终止， 必修可以修改 loop
        // 让th退出run方法，从而终止 th线程 -> 通知方式
        System.out.println("主线程休眠10S");
        Thread.sleep(1000 * 10);
        th.setLoop(false);
    }
}

class Th extends Thread{
    int count = 0;
    private boolean loop = true;
    @Override
    public void run() {
        while (loop) {
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Th 运行中...." + (++count));
        }
    }

    public void setLoop(boolean loop) {
        this.loop = loop;
    }
}

3、线程方法

3.1、线程常用的方法一：

方法名说明
setName设置线程名称，使之与参数name相同
getName返回该线程的名字
start使该线程开始执行；Java虚拟机底层调用该线程的start0方法
run调用线程对象run方法
setPriority更改线程的优先级
getPriority获取线程的优先级
sleep在指定的毫秒数内让当前正在执行的线程休眠
interrupt中断进程

  • 注意事项和细节：

    • start底层会创建新的线程，调用run，run是一个简单方法调用，不会启动新线程
    • 线程优先级的范围

    image-20221203185642103

    • interrupt，中断线程，单并没有真正的结束线程，一般用于中断正在休眠线程
    • sleep：线程的静态方法，使当前线程休眠

演示：

/**
 * @author java小豪
 * @version 1.0.0
 * @date 2022/12/3
 * @description 线程方法的使用
 */
public class ThreadMethod01 {
    public static void main(String[] args) throws InterruptedException {
        // 测试方法
        Th th = new Th();
        th.setName("小豪");
        th.setPriority(Thread.MIN_PRIORITY);
        // 启动子线程
        th.start();

        // 主线程打印5 hi，然后进行中断，子线程休眠
        for (int i = 0; i <= 5; i++) {
            Thread.sleep(1000);
            System.out.println("hi " + i);
        }
        System.out.println(th.getName() + " 线程优先级 = " + th.getPriority());

        // 当执行到这里时，就会中断 th线程的休眠
        th.interrupt();

    }
}

class Th extends Thread {

    @Override
    public void run() {
        while (true){
            for (int i = 0; i <= 100; i++) {
                // Thread.currentThread().getName() 获取当前线程名称
                System.out.println(Thread.currentThread().getName() + "吃包子~~~~~~~~");
            }
            try {
                System.out.println(Thread.currentThread().getName() + "休眠中~~~~~~");
                Thread.sleep(20000);
            } catch (InterruptedException e) {
                // 当该线程执行到一个interrupt 方法时，就会catch 一个异常，可以加入自己的业务代码
                System.out.println(Thread.currentThread().getName() + "被interrupt中断了~~~~~~");
            }
        }
    }
}

3.2、线程的常用方法二：

方法名称解释说明
yield线程的礼让。让出CPU，让其他线程执行，但礼让的时间不确定，所以也不一定礼让成功
join线程的插队。插队线程一旦插入成功，则肯定先执行完插入的线程的所有任务

线程join说明：

image-20221203193312602

示例演示：

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

/**
 * @author java小豪
 * @version 1.0.0
 * @date 2022/12/3
 * @description 线程方法的使用
 */
public class ThreadMethod02 {
    public static void main(String[] args) throws InterruptedException {

        T2 t2 = new T2();
        t2.start();

        for (int i = 1; i<= 20; i++) {
            Thread.sleep(1000);
            System.out.println("主线程吃了" + i + " 包子");
            if (i == 5) {
                System.out.println("主线程让子线程先吃");
                // join，线程插队
                // t2.join(); 这里是让t2线程执行完毕

                Thread.yield();
                System.out.println("子线程吃完主线程接着吃");
            }
        }
    }
}

class T2 extends Thread {

    @Override
    public void run() {
        for (int i = 1; i <= 20; i++) {
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程吃了" + i + "包子");
        }
    }
}

3.3、用户线程和守护线程

  1. 用户线程：也叫工作线程，当线程的任务执行完或通知方式结束
  2. 守护线程：一般是为工作线程服务的，当所有的用户线程结束，守护线程自动结束
  3. 常见的守护线程：垃圾回收机制

演示示例：

/**
 * @author java小豪
 * @version 1.0.0
 * @date 2022/12/3
 * @description 守护线程演示
 */
public class ThreadMethod0 {
    public static void main(String[] args) throws InterruptedException {
        MyDaemonThread myDaemonThread = new MyDaemonThread();
        myDaemonThread.start();
        // 当主线程结束后，子线程自动结束，只需将子线程设置为守护线程即可
        myDaemonThread.setDaemon(true);
        for (int i = 1; i <= 10; i++) {
            System.out.println("小豪再敲代码");
            Thread.sleep(10000);
        }
    }
}

class MyDaemonThread extends Thread {
    @Override
    public void run() {
        for (; ;) {
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("小豪在和女友聊天......");
        }
    }
}

4、线程生命周期

线程状态。 线程可以处于以下状态之一：

  • NEW : 尚未启动的线程处于此状态。
  • RUNNABLE 在Java虚拟机中执行的线程处于此状态。
  • BLOCKED 被阻塞等待监视器锁定的线程处于此状态。
  • WAITING 正在等待另一个线程执行特定动作的线程处于此状态。
  • TIMED_WAITING 正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。
  • TERMINATED 已退出的线程处于此状态。

image-20221203203948478

实例演示：

/**
 * @author java小豪
 * @version 1.0.0
 * @date 2022/12/3
 * @description 线程的状态
 */
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 {

    @Override
    public void run() {
        while (true){
            for (int i = 0; i < 10; i++) {
                System.out.println("hi " + i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            break;
        }
    }
}

运行结果：

image-20221203204933521

5、Synchronized

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

  • 同步具体方法—Synchronized

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

使用synchronized解决火车票超卖问题

/**
 * @author java小豪
 * @version 1.0.0
 * @date 2022/12/3
 * @description 模拟售票
 */
public class SellTicket {
    public static void main(String[] args) {
        // 解决火车票超卖问题
        SellTicket03  sellTicket03 = new SellTicket03();
        Thread thread1 = new Thread(sellTicket03);
        Thread thread2 = new Thread(sellTicket03);
        Thread thread3 = new Thread(sellTicket03);

        thread1.start();
        thread2.start();
        thread3.start();
    }
}

/** 实现接口方式, 使用synchronized实现线程同步**/
class SellTicket03 implements Runnable{
    private  int ticketNum = 100;
    private boolean loop = true;
    public synchronized void m() { // 同步方法，在同一时刻，只能有一个线程来执行run方法
        if (ticketNum <= 0) {
            System.out.println("售票结束...");
            loop = false;
            return;
        }

        // 休眠50秒
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("窗口 " + Thread.currentThread().getName() + "售出一张票"
                + " 剩余票数 = " + (--ticketNum));
    }
    @Override
    public void run() {
        while (loop) {
            // m方法是一个同步方法
            m();
        }
    }
}

6、互斥锁

基本介绍：

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

image-20221204221602909

  • 同步方法（静态的）的锁为当前类本身

image-20221204222202804

注意事项和细节：

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

7、死锁

基本介绍：

多个线程都占用了对方的锁资源，始终不肯释放，就导致了死锁

案例演示：

/**
 * @author java小豪
 * @version 1.0.0
 * @date 2022/12/4
 * @description 死锁模拟
 */
public class DeadLock_ {
    public static void main(String[] args) {
        // 模拟死锁现象
        DeadLockDemo A = new DeadLockDemo(true);
        A.setName("A线程");
        DeadLockDemo B = new DeadLockDemo(false);
        B.setName("B线程");
        A.start();
        B.start();
    }
}

class DeadLockDemo extends Thread {
    static Object o1 = new Object();
    static Object o2 = new Object();
    boolean flag;

    public DeadLockDemo(boolean flag) {
        this.flag = flag;
    }

    @Override
    public void run() {
        // 1.如果flag为 T，线程A 就会先得到 o1对象锁， 然后尝试去获取 o2 对象锁
        // 2.如果线程A 得不到 o2 对象锁，就会Blocked
        // 3.如果flag为 F, 线程B 就会先得到 o2对象锁，然后尝试去获取 o1 对象锁
        // 4.如果线程B 得不到 o1 对象锁， 就会Blocked
        if (flag) {
            synchronized (o1) {
                System.out.println(Thread.currentThread().getName() + " 进入1");
                synchronized (o2) {
                    System.out.println(Thread.currentThread().getName() + " 进入2");
                }
            }
        } else {
            synchronized (o2) {
                System.out.println(Thread.currentThread().getName() + " 进入3");
                synchronized (o1) {
                    System.out.println(Thread.currentThread().getName() + " 进入4");
                }
            }
        }
    }
}

释放锁

  • 下面操作会释放锁
    • 当前线程的同步方法、同步代码块执行结束
    • 当前线程在同步代码块、同步方法中遇到break、return
    • 当前线程在同步代码块、同步方法中出现了未处理的Error或者Exception，导致异常结束
    • 当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁
  • 下面操作不会释放锁
    • 线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行，不会释放锁
    • 线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁应避免suspend()和resume()方法来控制线程

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/67770.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

基于鲸鱼算法优化的lssvm回归预测-附代码

基于鲸鱼算法优化的lssvm回归预测-附代码

基于鲸鱼算法优化的lssvm回归预测 - 附代码 文章目录基于鲸鱼算法优化的lssvm回归预测 - 附代码1.数据集2.lssvm模型3.基于鲸鱼算法优化的LSSVM4.测试结果5.Matlab代码摘要&#xff1a;为了提高最小二乘支持向量机&#xff08;lssvm&#xff09;的回归预测准确率&#xff0c;对…
阅读更多...
行列式基础

行列式基础

进阶版&#xff1a;&#xff08;努力更新中&#xff09; 二阶行列式 我们先来看看二元一次方程。 {a1,1x1a1,2x2b1a2,1x2a2,2x2b2\left\{ \begin{matrix} a_{_{1,1}} x_{_1} a_{_{1,2}} x_{_2} b_{_1} \\ \\ a_{_{2,1}} x_{_2} a_{_{2,2}} x_{_2} b_{_2} \end{matrix} \ri…
阅读更多...
[附源码]计算机毕业设计葡萄酒销售管理系统论文Springboot程序

[附源码]计算机毕业设计葡萄酒销售管理系统论文Springboot程序

项目运行 环境配置&#xff1a; Jdk1.8 Tomcat7.0 Mysql HBuilderX&#xff08;Webstorm也行&#xff09; Eclispe&#xff08;IntelliJ IDEA,Eclispe,MyEclispe,Sts都支持&#xff09;。 项目技术&#xff1a; SSM mybatis Maven Vue 等等组成&#xff0c;B/S模式 M…
阅读更多...
【算法篇】利用堆高效解决大数据量时TOP-K问题

【算法篇】利用堆高效解决大数据量时TOP-K问题

Top-k问题1.问题描述2.分析问题3.思路4.复杂度分析5.代码实现6.总结堆相关博客&#xff1a; 堆1.问题描述 TOP-K问题&#xff1a;即求数据结合中前K个最大的元素或者最小的元素&#xff0c;一般情况下数据量都比较大。 比如&#xff1a;专业前10名、世界500强、富豪榜、游戏中前…
阅读更多...
C语言第十九课：补充知识——函数栈帧的创建与销毁

C语言第十九课：补充知识——函数栈帧的创建与销毁

目录 前言&#xff1a; 一、寄存器&#xff1a; 二、函数栈帧的创建与销毁&#xff1a; 1.main函数函数栈帧开辟的准备&#xff1a; 2.main函数函数栈帧的开辟&#xff1a; 3.Add函数函数栈帧的开辟&#xff1a; 4.Add函数函数栈帧的销毁&#xff1a; 5.main函数函数栈帧的销…
阅读更多...
Linux多线程

Linux多线程

Linux多线程 文章目录Linux多线程1.Linux线程概念1.1 什么是线程1.2 线程的执行流1.3 线程的优缺点1.4 线程的异常与用途2.进程与线程的区别总结3.多进程与多线程的应用场景4.线程控制4.1 进程ID与线程ID4.2 线程创建(pthread_create)4.3 线程终止(pthread_exit、pthread_cance…
阅读更多...
Unity计算着色器 01

Unity计算着色器 01

序 计算着色器&#xff0c;是什么&#xff1f; Unity中ComputeShader的基础介绍与使用 - 知乎 (zhihu.com) 好像是并行计算的一个东西。再具体的&#xff0c;看不懂了。 并行计算&#xff0c;显卡&#xff1f; 那看来得先了解显卡&#xff0c;铺垫一下&#xff0c;再计划…
阅读更多...
算法前缀和

算法前缀和

一 和为 k 的子数组 1.1 题目描述 给定一个整数数组和一个整数 k &#xff0c;请找到该数组中和为 k 的连续子数组的个数。 示例 1&#xff1a; 输入:nums [1,1,1], k 2 输出: 2 解释: 此题 [1,1] 与 [1,1] 为两种不同的情况 示例 2&#xff1a; 输入:nums [1,2,3], k…
阅读更多...
由浅入深，详解 LiveData 的那些事

由浅入深，详解 LiveData 的那些事

引言 关于LiveData,在2022尾声的今天&#xff0c;从事 Android 开发的小伙伴一定不会陌生。相应的&#xff0c;关于 LiveData 解析与使用的文章更是数不胜数&#xff0c;其中不乏优秀的创作者&#xff0c;在众多的文章以及前辈面前&#xff0c;本篇也不敢妄谈能写的多么深入,易…
阅读更多...
python使用Flask，Redis和Celery的异步任务

python使用Flask，Redis和Celery的异步任务

介绍 随着Web应用程序的发展和使用的增加&#xff0c;用例也变得多样化。我们现在正在建设和使用网站来执行比以往任何时候都更复杂的任务。其中一些任务可以进行处理&#xff0c;并将反馈立即转发给用户&#xff0c;而其他任务则需要稍后进行进一步处理和结果转发。越来越多地…
阅读更多...
冯诺依曼体系各硬件工作原理解析

冯诺依曼体系各硬件工作原理解析

文章目录计算机结构体系来源冯诺依曼体系结构主存储器的基本组成运算器的基本组成控制器的基本组成计算机的工作过程总结计算机结构体系来源 1946年,美国发明了世界上第一台计算机ENIAC,可用于比较快速的数据计算,但是其运算速度却受到了人工数据的输入速度的限制,为此我们现在…
阅读更多...
NNDL实验 优化算法3D轨迹 鱼书例题3D版

NNDL实验 优化算法3D轨迹 鱼书例题3D版

这张图在网络上很流行。代码源自&#xff1a; 深度学习入门&#xff1a;基于Python的理论与实现 (ituring.com.cn) 2D版讲解&#xff1a;NNDL 作业11&#xff1a;优化算法比较 调整学习率等超参数&#xff0c;观察动画&#xff0c;可以加深对各种算法的理解。 配合实验的模型…
阅读更多...
南方农业杂志南方农业杂志社南方农业编辑部2022年第19期目录

南方农业杂志南方农业杂志社南方农业编辑部2022年第19期目录

遗传育种 峨眉黑鸡遗传多样性及群体遗传结构分析 袁霞;刘方庆;文陇英;徐婧;廖光祥;王强胜;王湘; 1-7 栽培与植保《南方农业》投稿&#xff1a;cn7kantougao163.com 井窖式移栽烤烟前期地上部和地下部生长规律拟合分析 温明霞;郭发文;冯小芽;王军;刘京;彭剑涛;廉云; 8-1…
阅读更多...
从进程的角度来看JVM的内存分布

从进程的角度来看JVM的内存分布

JVM(下面JVM都是指代HotSpot)本质上是运行在操作系统上的一个C程序&#xff0c;本文会从这个角度来构建对于JVM内存的完整视角&#xff0c;以HotSpot这个JVM实现运行在Linux操作系统上进行分析&#xff0c;在分析的过程中会解释清楚一些不太好理解的概念&#xff0c;诸如堆外内…
阅读更多...
双十二哪些数码好物值得入手？盘点双十二最值得入手的数码好物

双十二哪些数码好物值得入手？盘点双十二最值得入手的数码好物

双十二快到了&#xff0c;相信很多人像我一样想趁着年末入手数码产品&#xff0c;但又不知道什么值得入手。最近也听到很多人问&#xff0c;针对这个问题&#xff0c;我来给大家盘点双十二最值得入手的数码好物&#xff0c;有需要的可以当个参考。 一、南卡小音舱蓝牙耳机 推…
阅读更多...
怎样批量查询网站是否被搜狗收录？批量查询网站搜狗收录的详细教程

怎样批量查询网站是否被搜狗收录？批量查询网站搜狗收录的详细教程

怎样批量查询网站是否被搜狗收录&#xff1f;批量查询网站搜狗收录的详细教程 批量查询网站搜狗收录的的具体操作&#xff1a; 第一步、打开站长工具 第二步、添加需要查询的网站域名 第三步、勾选要查询的功能&#xff08;勾选搜狗是否收录和搜狗总收录) 第四步、提交查询 第…
阅读更多...
手把手教你在Ubuntu22.04 上安装 Vivado、HLS、Vitis 2022.2版本

手把手教你在Ubuntu22.04 上安装 Vivado、HLS、Vitis 2022.2版本

文章目录1 Vivado22.2 和 HLS 22.2 安装下载安装包执行.bin文件开始安装命令配置启动问题2 Vitis 22.2 安装3 卸载Xilinx我是 雪天鱼&#xff0c;一名FPGA爱好者&#xff0c;研究方向是FPGA架构探索和数字IC设计。欢迎来关注我的B站账号&#xff0c;我将定期更新IC设计教程。 …
阅读更多...
手撕红黑树 | 变色+旋转你真的明白了吗？【超用心超详细图文解释 | 一篇学会Red_Black_Tree】

手撕红黑树 | 变色+旋转你真的明白了吗？【超用心超详细图文解释 | 一篇学会Red_Black_Tree】

说在前面 我们也很久没有更新数据结构系列了&#xff0c;半年前博主重新深入学习了红黑树这个数据结构&#xff0c;一直想更新呈现给大家&#xff0c;最近也一直没有时间&#xff0c;今天红黑树它来了&#xff01; 博主为了这篇博客&#xff0c;做了很多准备&#xff0c;试了…
阅读更多...
怎么修复老照片?给你推荐这几个修复方法

怎么修复老照片?给你推荐这几个修复方法

相信大家的家里都有老照片吧&#xff0c;那在你们翻看这些老照片的时候&#xff0c;有没有发现有些老照片变得有些破旧、泛黄、模糊等情况呢&#xff1f;看到这些情况&#xff0c;大家是不是会很心疼呢&#xff1f;因为这些老照片都充满了各种各样的回忆&#xff0c;根本拍不出…
阅读更多...
Docker查看容器的初始启动命令参数的常见几种方式

Docker查看容器的初始启动命令参数的常见几种方式

1.在使用docker容器的过程中&#xff0c;经常需要查看容器启动的命令来看当时启动容器时候所用的参数&#xff0c;如果时间不是很久或者通过history命令就可以很容易的想起或查看到命令&#xff0c;一旦时间过了很久或history被清空那么就无法获取命令&#xff0c;如下所示dock…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023