Java多线程：多线程 Thread 类 中常用的方法的使用

news2024/11/23 3:45:47

Java多线程：多线程 Thread 类 中常用的方法的使用

在这里插入图片描述

每博一文案

日本有一位方丈曾在其寺庙的公告栏上写下一句标语： ”没有失败的人生才最失败。“
深以为然，不上高山，不知平地，不经大海，不懂宽阔的涵义，人生需要许多试错的机会，各种滋味需要亲自
尝过，才知酸甜苦辣，人有了经历，才会长阅历，有了阅历，才会逐渐成熟自如。
稻盛和夫曾说：”在富裕的现代生活中，我们很难让孩子历经艰辛。“正因为如此，我们才应该告诉他们塑造人格
最重要的是经历辛苦，而且我们必须让这种想法根植于理性之中。
不经一番寒彻骨，怎得梅花扑鼻香。你来时走过的每一步，都算数。哪怕是走了歪路，绕了远路，那些经过的风景，
偶然发现的新方向，浪费的时间。都会以你意想不到的方式，回馈与你。
这些或欢喜，或痛苦的经历，都将成为生命中不可复制的财富，助你奔向更美好的未来。
                                            ——————   一禅心灵庙语

文章目录

  • Java多线程：多线程 Thread 类 中常用的方法的使用
    • 每博一文案
    • 1. start( ) 介绍 与 使用
    • 2. run( ) 介绍 与 使用
      • 2.1 start() 和 直接调用 run()的区别说明
    • 3. currentThread( ) 介绍 与 使用
    • 4. getName( ) / setName( ) 介绍 与 使用
    • 5. yield( ) 介绍 与 使用
    • 6. sleep( ) 介绍 与 使用
    • 7. join( ) 介绍 与 使用
    • 8. isAlive() 介绍 与 使用
    • 9. 总结：
    • 10. 最后：

该文章主要介绍：关于 Thread 类中的一些常用方法的 介绍 和 使用。

1. start( ) 介绍 与 使用

start( ) ： 方法的作用是启动一个新线程，新线程会执行相应的run()方法。并且对于同一个对象的线程，不可以调用 start()方法两次不然会报异常 (IllegalThreadStateException) 非法线程异常，仅仅只能调用一次start()方法。

在这里插入图片描述

Thread 类中的 start() 的源码：

public synchronized void start() {
    /**
         * This method is not invoked for the main method thread or "system"
         * group threads created/set up by the VM. Any new functionality added
         * to this method in the future may have to also be added to the VM.
         *
         * A zero status value corresponds to state "NEW".
         */
    if (threadStatus != 0)
        throw new IllegalThreadStateException();

    /* Notify the group that this thread is about to be started
         * so that it can be added to the group's list of threads
         * and the group's unstarted count can be decremented.
     */
    group.add(this);

    boolean started = false;
    try {
        start0();
        started = true;
    } finally {
        try {
            if (!started) {
                group.threadStartFailed(this);
            }
        } catch (Throwable ignore) {
            /* do nothing. If start0 threw a Throwable then
                  it will be passed up the call stack */
        }
    }
}

同一个线程调用一次 start()方法没有问题如下:

package blogs.blog4;

/**
 * Thread 类中常用的一些方法的介绍和使用
 */
public class ThreadTest5 {
    public static void main(String[] args) {
        Thread thread = new Thread(new MyThread5());
        // 同一个线程对象,调用一次 start();
        thread.start();

        // main 主线程
        for(int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "--->" + i);
        }

    }
}


class MyThread5 implements Runnable {
    @Override
    public void run() {
        for(int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "--->" + i);
        }
    }
}

在这里插入图片描述

同一个线程对象，调用 start()方法两次会报错：的异常 IllegalThreadStateException 非法线程状态异常。 如下

package blogs.blog4;


/**
 * Thread 类中常用的一些方法的介绍和使用
 */
public class ThreadTest5 {
    public static void main(String[] args) {
        Thread thread = new Thread(new MyThread5());
        // 同一个线程对象,调用一次 start();
        thread.start();
        // 同一个线程对象，调用两个 start();方法报错
        thread.start();  // 报错

        // main 主线程
        for(int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "--->" + i);
        }

    }
}


class MyThread5 implements Runnable {
    @Override
    public void run() {
        for(int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "--->" + i);
        }
    }
}

在这里插入图片描述

可以创建两个线程，分别调用 start()方法

package blogs.blog4;


/**
 * Thread 类中常用的一些方法的介绍和使用
 */
public class ThreadTest5 {
    public static void main(String[] args) {
        Thread thread = new Thread(new MyThread5());
        // 同一个线程对象,调用一次 start();
        thread.start();
        // 创建第二个线程对象
        Thread thread2 = new Thread(new MyThread5());
        thread2.start();

        // main 主线程
        for(int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "--->" + i);
        }

    }
}


class MyThread5 implements Runnable {
    @Override
    public void run() {
        for(int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "--->" + i);
        }
    }
}

在这里插入图片描述

2. run( ) 介绍 与 使用

run() : 就和普通的成员方法一样，可以被重复调用。单独调用**run()**的话，会在当前线程中执行run()，而并不会启动新线程！

Thread 中的 run ()方法其实重写 Runnable 中的 run()的抽象方法。

run(): 通常需要重写Thread()类/Runnable 中的抽象方法，将创建的线程要执行的操作声明在此方法中(线程实际要处理的事务)

Thread 中的run()方法的源码：


public class Thread implements Runnable {
    /* What will be run. */
    private Runnable target;


/**
     * If this thread was constructed using a separate
     * <code>Runnable</code> run object, then that
     * <code>Runnable</code> object's <code>run</code> method is called;
     * otherwise, this method does nothing and returns.
     * <p>
     * Subclasses of <code>Thread</code> should override this method.
     *
     * @see     #start()
     * @see     #stop()
     * @see     #Thread(ThreadGroup, Runnable, String)
     */
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
}

Runnable 接口的源码:


package java.lang;

/**
 * The <code>Runnable</code> interface should be implemented by any
 * class whose instances are intended to be executed by a thread. The
 * class must define a method of no arguments called <code>run</code>.
 * <p>
 * This interface is designed to provide a common protocol for objects that
 * wish to execute code while they are active. For example,
 * <code>Runnable</code> is implemented by class <code>Thread</code>.
 * Being active simply means that a thread has been started and has not
 * yet been stopped.
 * <p>
 * In addition, <code>Runnable</code> provides the means for a class to be
 * active while not subclassing <code>Thread</code>. A class that implements
 * <code>Runnable</code> can run without subclassing <code>Thread</code>
 * by instantiating a <code>Thread</code> instance and passing itself in
 * as the target.  In most cases, the <code>Runnable</code> interface should
 * be used if you are only planning to override the <code>run()</code>
 * method and no other <code>Thread</code> methods.
 * This is important because classes should not be subclassed
 * unless the programmer intends on modifying or enhancing the fundamental
 * behavior of the class.
 *
 * @author  Arthur van Hoff
 * @see     java.lang.Thread
 * @see     java.util.concurrent.Callable
 * @since   JDK1.0
 */
@FunctionalInterface
public interface Runnable {
    /**
     * When an object implementing interface <code>Runnable</code> is used
     * to create a thread, starting the thread causes the object's
     * <code>run</code> method to be called in that separately executing
     * thread.
     * <p>
     * The general contract of the method <code>run</code> is that it may
     * take any action whatsoever.
     *
     * @see     java.lang.Thread#run()
     */
    public abstract void run();
}

直接调用 run() 方法并不会创建线程，仅仅只是一个方法之间的回调而已。

package blogs.blog4;


/**
 * Thread 类中常用的一些方法的介绍和使用
 */
public class ThreadTest5 {
    public static void main(String[] args) {
        Thread thread = new Thread(new MyThread5());

        // 直接调用 run()方法不会创建新的线程，仅仅只是方法之间的回调而已
        thread.run();

        // main 主线程
        for(int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "--->" + i);
        }

    }
}


class MyThread5 implements Runnable {
    @Override
    public void run() {
        for(int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "--->" + i);
        }
    }
}

在这里插入图片描述

2.1 start() 和 直接调用 run()的区别说明

  1. start() 方法会创建一个新线程，并由这个新线程启动调用 run()方法。
  2. 直接调用 run( ) 方法，并不会创建一个新线程而是由当前线程调用 run()方法，而且可以多次调用 run() 。
  3. 对于 start() 方法，同一个线程对象仅仅只能调用一次，调用第二次会报 ：IllegalThreadStateException 异常错误。

3. currentThread( ) 介绍 与 使用

currentThread() ：是一个静态方法，作用：返回当前执行的线程的引用：类似于 this 这样的引用。

在这里插入图片描述

package blogs.blog4;


/**
 * Thread 类中常用的一些方法的介绍和使用
 */
public class ThreadTest5 {
    public static void main(String[] args) {
        Thread thread = new Thread(new MyThread5());

        // 直接调用 run()方法不会创建新的线程，仅仅只是方法之间的回调而已
        thread.start();

        // main 主线程
        for(int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread());  // // 返回当前执行的线程的引用
            System.out.println(Thread.currentThread().getName() + "--->" + i);
        }

    }
}


class MyThread5 implements Runnable {
    @Override
    public void run() {
        for(int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread());   // 返回当前执行的线程的引用
            System.out.println(Thread.currentThread().getName() + "--->" + i);
        }
    }
}

在这里插入图片描述

4. getName( ) / setName( ) 介绍 与 使用

setName() ：对象方法，设置线程的名称。

在这里插入图片描述

getName() ：对象方法，获取到线程的名称

在这里插入图片描述

package blogs.blog4;


/**
 * Thread 类中常用的一些方法的介绍和使用
 */
public class ThreadTest5 {
    public static void main(String[] args) {
        Thread thread = new Thread(new MyThread5());

        // 直接调用 run()方法不会创建新的线程，仅仅只是方法之间的回调而已
        thread.start();
        thread.setName("分支线程");   // 设置线程名

        Thread.currentThread().setName("主线程");   // 设置主线程名，// 先通过Thread.currentThread()方法获取当前线程的引用

        // main 主线程
        for(int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName());
        }

    }
}


class MyThread5 implements Runnable {
    @Override
    public void run() {
        for(int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName());
        }
    }
}

在这里插入图片描述

5. yield( ) 介绍 与 使用

yield() 静态方法，作用：释放当前cpu执行的线程的占有的时间片(进入就绪状态)， 注意虽然释放了：但是下一次cpu可能执行的还是这个我们(刚刚释放掉的线程)，原因是：这个刚刚释放的线程又抢到(获取的)cpu的执行权限了。注意：yield() 并不会释放手中占有的锁 。

在这里插入图片描述

package blogs.blog4;


/**
 * Thread 类中常用的一些方法的介绍和使用
 */
public class ThreadTest5 {
    public static void main(String[] args) {
        Thread thread = new Thread(new MyThread5());

        // 直接调用 run()方法不会创建新的线程，仅仅只是方法之间的回调而已
        thread.start();
        thread.setName("分支线程");   // 设置线程名

        Thread.currentThread().setName("主线程");   // 设置主线程名，先通过Thread.currentThread()方法获取当前线程的引用

        // main 主线程
        for(int i = 0; i < 10; i++) {
            Thread.yield();  // 释放当前线程占用的时间片,(进入就绪状态)
            System.out.println(Thread.currentThread().getName() + "-->" + i);
        }

    }
}


class MyThread5 implements Runnable {
    @Override
    public void run() {
        for(int i = 0; i < 10; i++) {
            Thread.yield();  // 释放当前线程占用的时间片,(进入就绪状态)
            System.out.println(Thread.currentThread().getName() + "-->" + i);
        }
    }
}

在这里插入图片描述

6. sleep( ) 介绍 与 使用

sleep() 的作用是让当前线程休眠，即当前线程会从 “运行状态” 进入到 “休眠(阻塞)状态”。 sleep()会指定休眠时间，线程休眠的时间会 大于/等于 该休眠时间；在线程重新被唤醒时，它会由 "阻塞状态" 变成 “就绪状态”，从而 等待cpu的调度执行 。

sleep( long millis ) 中的的参数中的单位是：毫秒。注意还要处理一个异常。

在这里插入图片描述

Thread.sleep(1000 * 1);      // 休眠 1 秒
Thread.sleep(1000 * 60);      // 休眠 1 分钟
Thread.sleep(1000 * 60 * 60);     // 休眠 1 小时
Thread.sleep(1000 * 60 * 60 * 24);  // 休眠 一天
Thread.sleep(1000 * 60 * 60 * 24 * 365 );  // 休眠 1 年

package blogs.blog4;


/**
 * Thread 类中常用的一些方法的介绍和使用
 */
public class ThreadTest5 {
    public static void main(String[] args) {
        Thread thread = new Thread(new MyThread5());

        // 直接调用 run()方法不会创建新的线程，仅仅只是方法之间的回调而已
        thread.start();
        thread.setName("分支线程");   // 设置线程名

        Thread.currentThread().setName("主线程");   // 设置主线程名，先通过Thread.currentThread()方法获取当前线程的引用

        // main 主线程
        for(int i = 0; i < 10; i++) {
            try {
                Thread.sleep(1000 * 1 );  // 休眠 1 秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "-->" + i);
        }

    }
}


class MyThread5 implements Runnable {
    @Override
    public void run() {
        for(int i = 0; i < 10; i++) {
            try {
                Thread.sleep(1000 * 1 );  // 休眠 1 秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "-->" + i);
        }
    }
}

在这里插入图片描述

注意的是 sleep() 是静态方法，与对象无关，所以休眠的是当前执行的线程，不是调用的sleep()方法的对象线程。

如下，休眠的是 main 的主线程。

public class ThreadTest5 {

    public static void main(String[] args) {
        // 创建匿名实现 Runnable 的实现类
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println(Thread.currentThread().getName() + "-->" + i);
                }
            }
        });

        thread.start();

        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(1000 * 1);  // 休眠 1 秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "-->" + i);
        }

    }
}

在这里插入图片描述

7. join( ) 介绍 与 使用

join() : 方法 作用是：让当前线程进入等待状态，不是对象调用 join()的对象线程进入等待状态，只有当调用 join()方法的对象线程执行完，当前等待状态的线程，才会往后执行。

在这里插入图片描述

如下：

当 main 主线程中的 for()循环中的 i == 5 的时候，main 主线程进入 等待状态 ，让调用 thread.join()的分支线程先执行完，main 主线程才可以从 等待状态 进入到 运行状态，继续执行 main 主线程后面的程序。

package blogs.blog4;


/**
 * Thread 类中常用的一些方法的介绍和使用
 */
public class ThreadTest5 {
    public static void main(String[] args) {
        Thread thread = new Thread(new MyThread5());

        // 直接调用 run()方法不会创建新的线程，仅仅只是方法之间的回调而已
        thread.start();
        thread.setName("分支线程");   // 设置线程名

        Thread.currentThread().setName("主线程");   // 设置主线程名，先通过Thread.currentThread()方法获取当前线程的引用

        // main 主线程
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "-->" + i);
            if (i == 5) {
                try {
                    thread.join();  // 当前线程停止，让 thread 分支线程执行完，再处理 Main 主线程中的程序
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}


class MyThread5 implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "-->" + i);
        }
    }
}

在这里插入图片描述

8. isAlive() 介绍 与 使用

isAlive() : 判断判断当前线程是否存活，如果存活 返回 true ,如果不存活，返回 false。

在这里插入图片描述

package blogs.blog4;


/**
 * Thread 类中常用的一些方法的介绍和使用
 */
public class ThreadTest5 {
    public static void main(String[] args) {
        Thread thread = new Thread(new MyThread5());

        // 直接调用 run()方法不会创建新的线程，仅仅只是方法之间的回调而已
        thread.start();
        thread.setName("分支线程");   // 设置线程名

        Thread.currentThread().setName("主线程");   // 设置主线程名，先通过Thread.currentThread()方法获取当前线程的引用

        // main 主线程
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "-->" + i);
            // 判断当前线程是否存活。
            System.out.println(Thread.currentThread().getName() + "-->" + Thread.currentThread().isAlive());  //
            if (i == 5) {
                try {
                    thread.join();  // 当前线程停止，让 thread 分支线程执行完，再处理 Main 主线程中的程序
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(thread.getName() + "-->" + thread.isAlive());

            }

        }
    }
}


class MyThread5 implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "-->" + i);
        }
    }
}

在这里插入图片描述

9. 总结：

  1. start() : 启动当前线程，调用当前线程的run()方法，一个线程对象仅仅只能调用一次 start() 不然报：IllegalThreadStateException) 非法线程异常。
  2. run(): 通常需要重写Thread()类/Runnable 中的抽象方法，将创建的线程要执行的操作声明在此方法中(线程实际要处理的事务)，直接调用 run()方法并不会创建新的线程，而是当前线程的简单的方法的调用，可以多次调用。
  3. currentThread()：静态方法，返回当前执行的线程的引用
  4. .setName()设置线程名,getName()获取线程名:如果是设置主线程名的话，需要先获取到当前执行的线程的引用: Thread.currentThread()。因为main主线程没有继承 Thread 类，无法直接调用父类中的方法。
  5. yield() 静态方法，作用：释放当前cpu执行的线程的占有的时间片(进入就绪状态)， 注意虽然释放了：但是下一次cpu可能执行的还是这个我们(刚刚释放掉的线程)，原因是：这个刚刚释放的线程又抢到(获取的)cpu的执行权限了。注意：yield() 并不会释放手中占有的锁 。
  6. sleep() 的作用是让当前线程休眠，即当前线程会从 “运行状态” 进入到 “休眠(阻塞)状态”。 sleep()会指定休眠时间，线程休眠的时间会 大于/等于 该休眠时间；在线程重新被唤醒时，它会由 "阻塞状态" 变成 “就绪状态”，从而 等待cpu的调度执行 。sleep( long millis ) 中的的参数中的单位是：毫秒。注意还要处理一个异常。
  7. join() : 方法 作用是：让当前线程进入等待状态，不是对象调用 join()的对象线程进入等待状态，只有当调用 join()方法的对象线程执行完，当前等待状态的线程，才会往后执行。
  8. isAlive() : 判断判断当前线程是否存活，如果存活 返回 true ,如果不存活，返回 false。

10. 最后：

限于自身水平，其中存在的错误，希望大家给予指教，韩信点兵——多多益善，谢谢大家，后会有期，江湖再见 ！！！

在这里插入图片描述

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

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

相关文章

很少人知道的7个极酷HTML元素

很少人知道的7个极酷HTML元素

搜索很酷的HTML元素&#xff0c;尤其是当您不知道要查找什么时&#xff0c;通常就像被扔进一堆垃圾中一样动图别担心&#xff0c;我为你做了肮脏的工作&#xff01;在浏览了看似无穷无尽的HTML元素之后&#xff0c;我挖出了一些很少使用的宝石&#xff01;1. meter&progres…
阅读更多...
多线程Monitor工作原理

多线程Monitor工作原理

&#x1f34e;1. 什么是Monitor?我们都知道synchronized的作用是用来保证修饰的代码或者方法执行有且只有一个线程执行&#xff0c;也就是锁。那么在执行被锁住的方式时&#xff0c;synchronized就需要通过monitor来记录和保证锁的状态。所以monitor这里的作用其实就是起到了控…
阅读更多...
RFID固定资产管理系统实现批量“秒”级盘点

RFID固定资产管理系统实现批量“秒”级盘点

面对成千上万&#xff0c;乃至几十万的固定资产&#xff0c;如何能高效管理&#xff0c;做到管理无漏洞&#xff0c;盘点无错漏呢&#xff1f;很多企业和软件厂商都在考虑这个问题。现如今&#xff0c;随着物联网的发展&#xff0c;企业可批量实现固定资产的秒级盘点&#xff0…
阅读更多...
【C++核心编程】C++全栈体系（十一）

【C++核心编程】C++全栈体系（十一）

C核心编程 第四章 类和对象 七、多态 1. 多态的基本概念 多态是C面向对象三大特性之一 多态分为两类 静态多态: 函数重载 和 运算符重载属于静态多态&#xff0c;复用函数名动态多态: 派生类和虚函数实现运行时多态 静态多态和动态多态区别&#xff1a; 静态多态的函数…
阅读更多...
打印机共享遇到的常见问题与解决方法

打印机共享遇到的常见问题与解决方法

共享打印机提示错误0X000006d9 解决方法： 1、桌面找到计算机或此电脑，然后再图标上右键选择管理选项菜单； 2、在打开的计算机管理对话框中选择服务和应用程序选项； 3、双击服务和应用程序选项就会打开一个对话框，然后再选择服务菜单双击；
阅读更多...
01-JDK、JRE、JVM之间的区别?

01-JDK、JRE、JVM之间的区别?

1.JDK JDK(Java SE Development Kit)&#xff0c;Java标准开发包&#xff0c;它提供了编译、运⾏Java程序所需的各种⼯具和资源&#xff0c;包括Java编译器、Java运⾏时环境&#xff0c;以及常⽤的Java类库等. JDK安装目录中真正在运行java时起作用的是 bin、include、lib、…
阅读更多...
一网打尽链表的经典OJ题！链表必考笔试题第二弹

一网打尽链表的经典OJ题！链表必考笔试题第二弹

目录 0.前言 1.合并两个排序链表 1.1 实用小妙招 1.2代码书写 2.链表分割 3.链表的回文结构 4.相交链表 4.1 实用小妙招&#xff08;假定指针法&#xff09; 4.2代码书写 5. 复制带随机指针的链表 0.前言 本文代码及分析图片资源都以上传Gitee&#xff0c;可自取&a…
阅读更多...
【Java数据结构】堆与优先级队列（堆）的详解

【Java数据结构】堆与优先级队列（堆）的详解

文章目录 目录 文章目录 一、优先级队列(堆) 1.1优先级队列的概念 二、优先级队列的模拟实现 2.1堆的概念 2.2堆的存储方式 2.3堆的创建 2.4建堆的时间复杂度 2.5堆的插入和删除 三.常用的PriorityQueue介绍 3.1PriorityQueue特性 3.2PriorityQueue常用方法 3.3oj练习 一、优…
阅读更多...
CANoe-Model Editor介绍以及如何创建一个服务

CANoe-Model Editor介绍以及如何创建一个服务

Model Editor，模型编辑器，可以打开导入的ARXML文件，编辑现有的或定义新的应用层对象（CO、DO） 什么是CO和DO？ Model Editor页面的整体布局为： 在左侧的子窗口中，你可以选择要编辑的内容根据你的选择，相应的内容将显示在右侧根据你在此处的选择，你可以使用其他拆分器来…
阅读更多...
Vue--》Vue3的setup语法糖到底香不香？你来看看就知道了

Vue--》Vue3的setup语法糖到底香不香？你来看看就知道了

目录 setup语法糖 创建Vue3项目 setup语法糖的使用 快速生成setup语法糖模板 setup语法糖新增的API useSlots()和useAttrs() 顶层await setup语法糖 相信在了解过这篇文章的 setup函数讲解 人会觉得Vue3处理数据变得繁琐了&#xff0c;所有的变量都必须return出来才能使…
阅读更多...
8步，用python实现进行自动化评论、点赞、关注脚本

8步，用python实现进行自动化评论、点赞、关注脚本

嗨害大家好鸭&#xff01; 我是小熊猫~ 分享这个没啥&#xff0c;就是好玩 这里写目录标题嗨害大家好鸭&#xff01; 我是小熊猫~开发环境代码实现点击此处跳转文末名片获取1.请求伪装2.获取关键词3. 获取作品评论ID采集4. 设置评论相应内容5. 设置点赞操作6. 设置关注操作7. 获…
阅读更多...
数据结构实验头歌 第1关：求图的最短路径

数据结构实验头歌 第1关：求图的最短路径

任务描述 本关任务&#xff1a;编程实现求图的最短路径 相关知识 最短路径的Dijkstra算法&#xff1a; 求最短路径就是求图中的每一个点到图中某一个给定点&#xff08;认为编号为0的点&#xff09;的最短距离。 具体算法就是初始有一个旧图&#xff0c;一个新图。开始时旧图中…
阅读更多...
Linux项目自动化构建工具-make/Makefifile

Linux项目自动化构建工具-make/Makefifile

目录 背景 实例代码 依赖关系 依赖方法 原理 项目清理 可重复执行的依据 背景 会不会写makefile&#xff0c;从一个侧面说明了一个人是否具备完成大型工程的能力 一个工程中的源文件不计数&#xff0c;其按类型、功能、模块分别放在若干个目录中&#xff0c;makefile定义了一系…
阅读更多...
K8s部署前后端分离项目（一）

K8s部署前后端分离项目（一）

K8s部署前后端分离项目 环境准备 K8s环境 主节点master&#xff1a;192.168.3.200 子节点node1&#xff1a;192.168.3.201 子节点node2&#xff1a;192.168.3.202 Harbor远程仓库 已部署在master主节点上&#xff0c;目录为&#xff1a;cd /workspace/harbor/harbor 1、登录地…
阅读更多...
java使用XDocReport导出word

java使用XDocReport导出word

使用XDocReport 导出word效果word编辑器案例word模板模板制作解决图片不存在时, "现场照片" 列被隐藏问题依赖返回数据对象 DailyRecordReportOpinionVO 审核记录对象PicVo 图片对象导出接口效果 说明: “现场图片” 为动态图片列表 , “专业负责人审核意见” 和 “项…
阅读更多...
freeswitch的多租户模式

freeswitch的多租户模式

概述 freeswitch是一款简单好用的VOIP开源软交换平台。 现在的VOIP服务越来越倾向于云端服务&#xff0c;包括呼叫中心云服务&#xff0c;线路云平台。 而云平台对多个客户的服务就需要做好隔离&#xff0c;包括数据隔离、线路隔离、服务隔离等。 freeswitch内部的多租户模…
阅读更多...
如何给视频批量添加背景图的实例操作教程

如何给视频批量添加背景图的实例操作教程

如何给视频添加上背景图片呢&#xff1f;有需要的宝宝跟着小编一起来看看怎么操作的吧。 先运行【云炫AI智剪】&#xff0c;然后再选择画中画&#xff0c;切换相对应的界面当中。 接下来把底画背景图导入到列表中&#xff0c;可以选中文件直接拖动到软件中&#xff0c;或者…
阅读更多...
多次执行相同的push、replace问题（重写push、replace）

多次执行相同的push、replace问题（重写push、replace）

1.多次执行相同的push、replace问题编程式导航路由跳转到当前路由(参数不变), 多次执行会抛出NavigationDuplicated的警告错误注意:编程式导航&#xff08;push|replace&#xff09;才会有这种情况的异常&#xff0c;声明式导航是没有这种问题&#xff0c;因为声明式导航内部已…
阅读更多...
你是真的“C”——详解C语言函数模块知识(上篇）

你是真的“C”——详解C语言函数模块知识(上篇）

详解C语言函数模块知识(上篇&#xff09;&#x1f60e;前言&#x1f64c;1. 函数是什么⁉️2、C语言中函数的分类&#x1f64c;库函数&#xff1a;&#x1f603;自定义函数&#x1f603;**这里通过几个例子来辅助大家更好的理解函数如何用** ⁉️1、实现一个函数来交换两个整数…
阅读更多...
C语言实现静态通讯录

C语言实现静态通讯录

专栏&#xff1a;C语言 每日一句&#xff1a;这几年可能会有点累&#xff0c;但要相信你的人生不可能就止于此地了&#xff0c;你要有你的梦想&#xff0c;所以你要努力&#xff0c;只有坚持这阵子&#xff0c;才不会辛苦一辈子&#xff0c;努力会让自己过得很好&#xff0c; 静…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023