【JavaEE】定时器

已于 2024-08-04 14:15:12 修改
阅读量963 收藏 23
点赞数 29
分类专栏： java 文章标签： java-ee java 定时器
于 2024-08-04 14:13:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhyhgx/article/details/140904178
版权

目录

前言

什么是定时器

如何使用java中的定时器

实现计时器

实现MyTimeTask类

Time类中存储任务的数据结构

实现Timer中的schedule方法

 实现MyTimer中的构造方法

处理构造方法中出现的线程安全问题

完整代码

 考虑在限时等待wait中能否用sleep替换

能否用PriorityBlockingQueue进行存储

在前面，已经讲解了几种常见设计模式，那么今天我们就来讲解一下定时器。

前言

在发送信息的时候，有时候不想要信息那么快就发送出去，而是在特定的时间再发送；或者我们在发送邮件时，当达到特定的时间时，就会自动发送电子邮件给用户，那么这里就需要用到定时器，那么定时器是什么呢？

什么是定时器

定时器是软件开发中的一个重要组件，类似于“闹钟”，能够在某个特定的时间执行一个或者多个任务，定时器是多线程中的一个案例，也是一个比较复杂且重要的案例。

如何使用java中的定时器

在java中，给我们提供了实现了的定时器包，我们可以直接使用。

java中给我们提供的定时器是Timer，我们在设置定时任务时，需要用到其中的schedule方法。

schedule包含两个参数：

第⼀个参数指定即将要执⾏的任务代码

第⼆个参数指定多⻓时间之后 执⾏(单位为毫秒)

示例：

class Demos{
    public static void main(String[] args) {
        // 创建一个Timer对象，用于调度定时任务
        Timer timer=new Timer();
        
        // 调度第一个定时任务，1秒后执行
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("hello");
            }
        },1000);
        
        // 调度第二个定时任务，2秒后执行
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("hello");
            }
        },2000);
        
        // 调度第三个定时任务，3秒后执行
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("hello");
            }
        },3000);
    }

}

实现计时器

我们从上述代码中可以看出，要实现一个定时器，需要实现以下：

  1. 实现一个任务（Task）类
  2. 实现一个Timer类用来存放任务

实现MyTimeTask类

/**
 * TimeTask类用于封装一个延迟执行的任务
 * 它包含一个需要执行的任务和一个延迟时间
 */
class TimeTask{
    //需要执行的任务
    private Runnable runnable;
    //任务等待执行的时间点，以毫秒为单位
    private long time;

    /**
     * 构造函数，用于创建一个TimeTask对象
     * @param runnable 需要延迟执行的任务，类型为Runnable
     * @param delay    任务延迟执行的时间，单位为毫秒
     */
    public TimeTask(Runnable runnable,long  delay){
        this.runnable=runnable;
        //计算任务应该执行的时间点
        this.time=System.currentTimeMillis()+delay;
    }

    /**
     * 返回任务的等待执行时间
     * @return 任务等待执行的时间点，以毫秒为单位
     */
    public long getTime(){
        return this.time;
    }

    /**
     * 执行当前任务
     * 调用构造时传入的Runnable对象的run方法来执行任务
     */
    public void run(){
        this.runnable.run();
    }
}

Time类中存储任务的数据结构

我们在存储任务的时候，需要根据等待时间来存储，时间短的优先取出来，那么我们就可以使用优先级队列，创建一个小根堆，时间最短的放在堆顶。

    private PriorityQueue<MyTimeTask> pq=new PriorityQueue<>();

但是我们这里要怎么比较呢？我们可以实现Comparable接口重写compareTo方法来进行比较，或者创建一个类来实现Comparator接口重写compare方法来进行比较。

实现Timer中的schedule方法

当我们解决了在任务在优先级队列中如何进行比较存储任务的问题之后，那么就可以在MyTimer中来实现schedule方法。根据schedule方法的参数创建一个MyTimeTask类，并将其添加到优先级队列中。

/**
 * 将一个 Runnable 任务安排在指定的延迟时间后执行
 * 
 * @param runnable 要执行的任务
 * @param delay    相对于现在的时间延迟，单位为毫秒
 * 
 * 注意：这个方法使用一个优先队列（pq）来管理这些被安排的任务，确保它们在指定的延迟后被执行
 */
public void schedule(Runnable runnable, long delay) {
    // 创建一个 MyTimeTask 对象，它包含了 Runnable 任务和延迟时间
    MyTimeTask myTimeTask = new MyTimeTask(runnable, delay);
    // 将 MyTimeTask 对象添加到优先队列 pq 中，以便在未来的某个时间执行
    pq.add(myTimeTask);
}

 实现MyTimer中的构造方法

通过实例化一个线程，在这个线程中，通过多次扫描优先级队列中的元素，判断堆顶元素是否到达了等待时长，若是，则取出并执行。

注意：这里不能直接poll取出栈顶元素，若栈顶的任务等待时间还未到达，则继续循环。

 /**
     * 构造函数，初始化MyTimer对象
     * 创建并启动一个线程，用于持续检查并执行已到达设定时间的任务
     */
    public MyTimer(){
        // 创建一个新的线程来执行定时任务
        Thread t=new Thread(()->{
            // 无限循环，持续检查任务队列
            while(true) {
                if(pq.isEmpty()){
                    continue;
                }
                // 查看在栈顶的任务
                MyTimeTask task = pq.peek();
                // 比较栈顶的任务与当前时间点的比较
                if (System.currentTimeMillis() >= task.getTime()) {
                    // 当前时间已达到任务设定时间，移除任务并执行
                    pq.poll();
                    task.run();
                }else {// 如果栈顶的任务时间大于当前时间，则继续循环
                    // 继续检查下一个任务，或在没有到达时间的任务时继续等待
                    continue;
                }
            }
        });
        // 启动线程
        t.start();
    }

处理构造方法中出现的线程安全问题

在上述代码中，能看出哪里存在线程安全问题吗？

优先级队列并不是一个线程安全的队列，我们在瞥（peek）取（poll）的时候，可能会出现线程安全问题，若是在多线程环境中，当线程1刚peek了堆顶任务，但此时切换到线程2，线程2同样peek堆顶任务，并刚好到了等待时间，此时就会执行并且删除栈顶任务。此时又切换到线程1，但此时线程1peek的堆顶任务已经被poll掉了，此时如果再执行，就会再次删除堆顶任务，导致出现线程安全问题。

所以，这里我们需要对peek和poll操作进行加锁。

    /**
     * 构造函数，初始化MyTimer对象
     * 创建并启动一个线程，用于持续检查并执行已到达设定时间的任务
     */
    public MyTimer(){
        // 创建一个新的线程来执行定时任务
        Thread t=new Thread(()->{
            // 无限循环，持续检查任务队列
            while(true) {
                synchronized (lock) {
                    // 如果任务队列为空，则跳过当前循环
                    if (pq.isEmpty()) {
                        continue;
                    }
                    // 查看在栈顶的任务
                    MyTimeTask task = pq.peek();
                    // 比较栈顶的任务与当前时间点的比较
                    if (System.currentTimeMillis() >= task.getTime()) {
                        // 当前时间已达到任务设定时间，移除任务并执行
                        pq.poll();
                        task.run();
                    } else {// 如果栈顶的任务时间大于当前时间，则继续循环
                        // 继续检查下一个任务，或在没有到达时间的任务时继续等待
                        continue;
                    }
                }
            }
        });
        // 启动线程
        t.start();
    }

 这里还有什么能优化的吗？

我们可以看到，当优先级队列中不为空，但此时堆顶任务的等待时间还没到，此时就会进入else分支执行continue，但一直重复这样操作，可能会造成不断检查，cpu使用率过高。那么我们就可以使用带参数的wait来进行限时等待，当达到时限时，会自动唤醒线程。

同理的，在判断队列是否为空时，我们可以设置不带参数的wait，等待唤醒。

    /**
     * 构造函数，初始化MyTimer对象
     * 创建并启动一个线程，用于持续检查并执行已到达设定时间的任务
     */
    public MyTimer(){
        // 创建一个新的线程来执行定时任务
        Thread t=new Thread(()->{
            // 无限循环，持续检查任务队列
            while(true) {
                synchronized (lock) {
                    // 如果任务队列为空，则跳过当前循环
                    while (pq.isEmpty()) {
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }
                    // 查看在栈顶的任务
                    MyTimeTask task = pq.peek();
                    // 比较栈顶的任务与当前时间点的比较
                    if (System.currentTimeMillis() >= task.getTime()) {
                        // 当前时间已达到任务设定时间，移除任务并执行
                        pq.poll();
                        task.run();
                    } else {// 如果栈顶的任务时间大于当前时间，则继续循环
                        try {
                            lock.wait(task.getTime()-System.currentTimeMillis());
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }
                }
            }
        });
        // 启动线程
        t.start();
    }

既然这里等待，那么我们就需要有人来唤醒wait，所以我们在schedule方法中也需要进行加锁，并且在添加完任务后，调用notify来进行通知。

/**
     * 将一个 Runnable 任务安排在指定的延迟时间后执行
     *
     * @param runnable 要执行的任务
     * @param delay    相对于现在的时间延迟，单位为毫秒
     *
     * 注意：这个方法使用一个优先队列（pq）来管理这些被安排的任务，确保它们在指定的延迟后被执行
     */
    public void schedule(Runnable runnable, long delay) {
        synchronized (lock) {
            // 创建一个 MyTimeTask 对象，它包含了 Runnable 任务和延迟时间
            MyTimeTask myTimeTask = new MyTimeTask(runnable, delay);
            // 将 MyTimeTask 对象添加到优先队列 pq 中，以便在未来的某个时间执行
            pq.add(myTimeTask);
            // 唤醒可能在等待执行任务的线程
            lock.notify();
        }
    }

 MyTimer优化到这里，其实已经优化好了。

完整代码

package Threads;

import java.util.Comparator;
import java.util.PriorityQueue;

/**
 * TimeTask类用于封装一个延迟执行的任务
 * 它包含一个需要执行的任务和一个延迟时间
 */
class TimeTask implements Comparable<TimeTask>{
    //需要执行的任务
    private Runnable runnable;
    //任务等待执行的时间点，以毫秒为单位
    private long time;

    /**
     * 构造函数，用于创建一个TimeTask对象
     * @param runnable 需要延迟执行的任务，类型为Runnable
     * @param delay    任务延迟执行的时间，单位为毫秒
     */
    public TimeTask(Runnable runnable,long  delay){
        this.runnable=runnable;
        //计算任务应该执行的时间点
        this.time=System.currentTimeMillis()+delay;
    }

    /**
     * 返回任务的等待执行时间
     * @return 任务等待执行的时间点，以毫秒为单位
     */
    public long getTime(){
        return this.time;
    }

    /**
     * 执行当前任务
     * 调用构造时传入的Runnable对象的run方法来执行任务
     */
    public void run(){
        this.runnable.run();
    }


    @Override
    public int compareTo(TimeTask o) {
        return (int) (this.time- o.getTime());

    }
}
class MyTimer{
    //private PriorityQueue<MyTimeTask> pq=new PriorityQueue<>(new compareTimeTask());
    private PriorityQueue<MyTimeTask> pq=new PriorityQueue<>();
    static Object lock=new Object();

    /**
     * 构造函数，初始化MyTimer对象
     * 创建并启动一个线程，用于持续检查并执行已到达设定时间的任务
     */
    public MyTimer(){
        // 创建一个新的线程来执行定时任务
        Thread t=new Thread(()->{
            // 无限循环，持续检查任务队列
            while(true) {
                synchronized (lock) {
                    // 如果任务队列为空，则跳过当前循环
                    while (pq.isEmpty()) {
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }
                    // 查看在栈顶的任务
                    MyTimeTask task = pq.peek();
                    // 比较栈顶的任务与当前时间点的比较
                    if (System.currentTimeMillis() >= task.getTime()) {
                        // 当前时间已达到任务设定时间，移除任务并执行
                        pq.poll();
                        task.run();
                    } else {// 如果栈顶的任务时间大于当前时间，则继续循环
                        try {
                            lock.wait(task.getTime()-System.currentTimeMillis());
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }
                }
            }
        });
        // 启动线程
        t.start();
    }




    /**
     * 将一个 Runnable 任务安排在指定的延迟时间后执行
     *
     * @param runnable 要执行的任务
     * @param delay    相对于现在的时间延迟，单位为毫秒
     *
     * 注意：这个方法使用一个优先队列（pq）来管理这些被安排的任务，确保它们在指定的延迟后被执行
     */
    public void schedule(Runnable runnable, long delay) {
        synchronized (lock) {
            // 创建一个 MyTimeTask 对象，它包含了 Runnable 任务和延迟时间
            MyTimeTask myTimeTask = new MyTimeTask(runnable, delay);
            // 将 MyTimeTask 对象添加到优先队列 pq 中，以便在未来的某个时间执行
            pq.add(myTimeTask);
            // 唤醒可能在等待执行任务的线程
            lock.notify();
        }
    }

}
class Demo{
    public static void main(String[] args) {
        MyTimer timer=new MyTimer();
        timer.schedule(()->{
            System.out.println("Hello World1");
        },1000);
        timer.schedule(()->{
            System.out.println("Hello World2");
        },2000);
        timer.schedule(()->{
            System.out.println("Hello World3");
        },3000);
    }
}
class compareTimeTask implements Comparator<MyTimeTask>{

    @Override
    public int compare(MyTimeTask o1, MyTimeTask o2) {
        return (int) (o1.getTime()-o2.getTime());
    }
}

测试一下

 考虑在限时等待wait中能否用sleep替换

 Thread.sleep(task.getTime()-System.currentTimeMillis());

 这里为什么不用sleep呢？

在前面线程安全问题中已经讲解了wait和sleep的区别，在这里，如果我们使用sleep，会导致拉着锁一起进入睡眠，导致其他线程拿不到锁对象，无法进行加锁。

这会导致我们想要调用schedule方法添加任务时，拿不到锁对象。

能否用PriorityBlockingQueue进行存储

在前面，我们用的是优先级队列PriorityBlockingQueue来存储任务，但如果我们用PriorityBlockingQueue呢？

如果我们使用PriorityBlockingQueue，那么我们的方法也需要改成take（取）和put（存），才能用阻塞等待的效果。

修改代码：

package Threads;

import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.concurrent.PriorityBlockingQueue;

/**
 * TimeTask类用于封装一个延迟执行的任务
 * 它包含一个需要执行的任务和一个延迟时间
 */
class TimeTask implements Comparable<TimeTask>{
    //需要执行的任务
    private Runnable runnable;
    //任务等待执行的时间点，以毫秒为单位
    private long time;

    /**
     * 构造函数，用于创建一个TimeTask对象
     * @param runnable 需要延迟执行的任务，类型为Runnable
     * @param delay    任务延迟执行的时间，单位为毫秒
     */
    public TimeTask(Runnable runnable,long  delay){
        this.runnable=runnable;
        //计算任务应该执行的时间点
        this.time=System.currentTimeMillis()+delay;
    }

    /**
     * 返回任务的等待执行时间
     * @return 任务等待执行的时间点，以毫秒为单位
     */
    public long getTime(){
        return this.time;
    }

    /**
     * 执行当前任务
     * 调用构造时传入的Runnable对象的run方法来执行任务
     */
    public void run(){
        this.runnable.run();
    }


    @Override
    public int compareTo(TimeTask o) {
        return (int) (this.time- o.getTime());

    }
}
class MyTimer{
    //private PriorityQueue<MyTimeTask> pq=new PriorityQueue<>(new compareTimeTask());
    private PriorityBlockingQueue<MyTimeTask> pq=new PriorityBlockingQueue<>(100);
    static Object lock=new Object();

    /**
     * 构造函数，初始化MyTimer对象
     * 创建并启动一个线程，用于持续检查并执行已到达设定时间的任务
     */
    public MyTimer(){
        // 创建一个新的线程来执行定时任务
        Thread t=new Thread(()->{
            // 无限循环，持续检查任务队列
            while(true) {
                synchronized (lock) {
                    // 如果任务队列为空，则跳过当前循环
                    while (pq.isEmpty()) {
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }
                    // 查看在栈顶的任务
                    MyTimeTask task = null;
                    try {
                        task = pq.take();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    // 比较栈顶的任务与当前时间点的比较
                    if (System.currentTimeMillis() >= task.getTime()) {
                        // 当前时间已达到任务设定时间，移除任务并执行
                        task.run();
                    } else {// 如果栈顶的任务时间大于当前时间，则继续循环
                        pq.put(task);
                        try {
                            lock.wait(task.getTime()-System.currentTimeMillis());
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }
                }
            }
        });
        // 启动线程
        t.start();
    }




    /**
     * 将一个 Runnable 任务安排在指定的延迟时间后执行
     *
     * @param runnable 要执行的任务
     * @param delay    相对于现在的时间延迟，单位为毫秒
     *
     * 注意：这个方法使用一个优先队列（pq）来管理这些被安排的任务，确保它们在指定的延迟后被执行
     */
    public void schedule(Runnable runnable, long delay) {
        synchronized (lock) {
            // 创建一个 MyTimeTask 对象，它包含了 Runnable 任务和延迟时间
            MyTimeTask myTimeTask = new MyTimeTask(runnable, delay);
            // 将 MyTimeTask 对象添加到优先队列 pq 中，以便在未来的某个时间执行
            pq.put(myTimeTask);
            // 唤醒可能在等待执行任务的线程
            lock.notify();
        }
    }

}
class Demo{
    public static void main(String[] args) {
        MyTimer timer=new MyTimer();
        timer.schedule(()->{
            System.out.println("Hello World1");
        },1000);
        timer.schedule(()->{
            System.out.println("Hello World2");
        },2000);
        timer.schedule(()->{
            System.out.println("Hello World3");
        },3000);
    }
}
class compareTimeTask implements Comparator<MyTimeTask>{

    @Override
    public int compare(MyTimeTask o1, MyTimeTask o2) {
        return (int) (o1.getTime()-o2.getTime());
    }
}

由于take会触发阻塞等待，而后面的wait也会，这里加了两次锁，容易引出线程安全问题，所以我们建议使用一个锁对象lock，来进行加锁就行。而不使用无界阻塞队列。

以上就是本篇所有内容~

若有不足，欢迎指正~

小猪同学hy
关注
  • 29
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 8
    评论
专栏目录
javaee实现定时器
Growing墨染轨迹
01-08 374
1：编写一个接口 public interface QuartzService { public void doWork(); } 2：编写接口的实现类 public class DemoQuartzServiceImpl implements QuartzService { @Override public void doWork() { /** * 1. 根据业务的需要自定义方法来实现逾期未...
Java代码借助JavaEE中的定时器定时关闭计算机
06-20
在这个特定的场景中，我们关注的是JavaEE中的定时器（Timer）功能，这个功能可以用来执行周期性的任务，比如定时关闭计算机。以下将详细讲解如何借助JavaEE的定时器来实现这一目标。 首先，JavaEE中的定时器服务...
JavaEE定时器
nnn9223643的专栏
04-24 732
package com.ovi.poi.tool; import java.util.Timer;//定时器类 import javax.servlet.ServletContextEvent; import javax.servlet.ServletContextListener; public class SysContextListener implements Se
JavaEE07 定时器的使用和模拟实现
qiuqiushuibx的博客
12-09 521
定时器的模拟实现
[JavaEE]定时器
Node_Hao的博客
01-19 2686
定时器类似于一个"闹钟" , 是软件开发中的一个重要组件 , 达到一个设定时间后就会执行某段代码.
JAVAEE-定时器案例
m0_73700505的博客
12-08 291
/创建计时器//此处为执行的任务代码//此处为执行任务的时间,此处的时间是一个相对时间,此处的时间是一个ms级别的时间戳//构造方法//获取时间的方法//提供任务执行的接口但是我们在定义计时器MYTIME这个类的时候,需要用一个优先级队列来进行存储task任务,因此task必须是可以进行比较的,不然会报错,因此,task这个类就要实现Comparable这个接口。
【JavaEE】定时器实例
qq_63230990的博客
03-29 465
class Timer{ //1.一个阻塞优先级队列 //2.一个静态内部类Task //3.方法schedule（任务，时间） //4.一个进程，执行定时器 //5.一个锁 //6.Timer的构造方法。 }
[JAVAee]定时器
weixin_67719939的博客
07-26 438
javaee Timer定时器
JavaEE 第11节 定时器
2301_80636143的博客
08-16 508
定时器的概念非常简单。它在软件开发中应用非常广泛。它类似于一个提前设定好的闹钟，到达指定时间后，执行设定好的任务程序。比如在网络通信中，如果在一个时间范围内没有得到响应，那么重新尝试连接网络等。
【JavaEE】线程池和定时器
2302_79806056的博客
08-15 1401
在深入研究Java并发编程的过程中，线程池和定时器是两个不可或缺的概念。它们不仅体现了Java在处理并发和定时任务上的强大功能，也反映了现代软件工程中资源管理和效率优化的重要性。以下是我在学习这两个主题后的总结与反思。线程池：高效资源管理的艺术线程池，顾名思义，是一个预先创建好的线程集合，用于执行提交的任务。它通过复用现有线程，避免了线程创建和销毁的开销，从而提高了系统的响应速度和资源利用率。线程池的配置参数，如核心线程数、最大线程数、工作队列类型等，需要根据具体的应用场景和系统资源进行细致调整。
JavaEE7-api 文档 中英 谷歌翻译版
03-19
3.2版本简化了EJB的使用，增加了轻量级会话bean，同时改进了定时器服务和无状态会话bean的行为。 6. **JPA 2.1**： - Java Persistence API（JPA）用于处理对象关系映射。2.1版本引入了嵌入式ID，支持多租户，以及...
JavaEE-SpringMVC-云借阅图书管理系统（包含源码、数据库sql文件、报告）
06-24
云借阅图书管理系统：全部源码打包。含有数据库sql文件，简单报告书介绍，通过课设验收。 架构： 持久对象层（持久层或持久化层）：该层由若干持久化类（实体类）组成。 数据访问层（DAO层）：该层由若干DAO接口和...
JAVAEE英语单词
12-14
4. clearInterval：用于取消由setInterval启动的定时器，确保资源的释放。 5. Document：JavaScript中的全局对象，代表HTML或XML文档，提供了访问和操作文档的方法和属性。 6. Mouse：与用户交互的设备，...
【JavaEE初阶】多线程(2)
2301_80898480的博客
09-07 1087
while(!isQuit){try {System.out.println("t线程结束.");});t.start();System.out.println("main线程尝试终止 t线程");//修改isQuit变量,就能够影响到t线程结束其中判断条件isQuit要写在main方法的外面 作为成员变量,内部类(lambda表达式本质上是一个'函数接口'产生的 匿名内部类)是可以访问外部类的成员知识复习:变量捕获变量捕获是lambda表达式/匿名内部类 的一个语法规则。
spring事务详细讲解-深入浅出
小电玩
09-08 351
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
最新发布
m0_63550220的博客
09-08 1340
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
JAVA基础：数据类型、命名规范
weixin_53755148的博客
09-05 1327
变量类型就是用来指定变量中存储数据的类型。也称为数据类型。
自定义Stater
m0_63624484的博客
09-07 671
我们平时在导入依赖的时候，大部分导入的都是xxx-spring-boot-stater。那是因为它们都基于spring的规则将写好的框架定义成一个stater，这样方便springboot引用它们写好的功能。那我们为什么也要自定义stater呢？
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小猪同学hy

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值