【JavaEE -- 多线程3 - 多线程案例】

最新推荐文章于 2024-05-06 21:32:45 发布
最新推荐文章于 2024-05-06 21:32:45 发布
阅读量1k 收藏 48
点赞数 55
分类专栏： Java EE 文章标签： java-ee java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63440113/article/details/136720843
版权

多线程案例

1.单例模式

单例模式：是一种设计模式，某个类，在一个进程中只创建出一个实例（对象），对代码进行一个更严格的校验和检查。

实现单例模式最基础的实现方式：

  • 饿汉模式：
  • 懒汉模式

1.1 饿汉模式的实现方法

单例模式中一种简单的写法，饿汉：形容创建实例非常迫切，实例是在类加载的时候就创建了，创建时机非常早，相当于程序一启动，实例就创建了。

class Singleton {
    // 在这个Singleton 被加载的时候，就会初始化这个静态成员
    private static Singleton instance = new Singleton();// instance 指向的这个对象，就是唯一的一个对象

    public static Singleton getInstance() {
    	// 对于饿汉模式，getInstance直接返回Instance实例，这个操作本质上是读操作，在多线程情况下读取同一个变量是线程安全的
        return instance;
    }

    private Singleton() {

    }
}

public class ThreadDemo26 {
    public static void main(String[] args) {
        // Singleton singleton = new Singleton(); //
        Singleton s = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();
        System.out.println(s == s2);

    }
}

1.2 懒汉模式的实现方法

懒汉模式：创建实例的时机比较晚，只到第一次使用的时候才会创建实例。
注意：

  • 在这个引用 指向唯一实例，这个引用先初始化为null，而不是立即创建实例
  • 由于在 instance = new SingletonLazy(); 实例化的时候有读有写，在多线程下是不安全的，会出现指令重排序的线程安全问题，通过添加volatile解决。
  • instance = new SingletonLazy(); 拆成三大步骤：
    1. 申请一段内存空间
    2. 在这内存上调用构造方法，创建出这个实例
    3. 把这个内存地址赋值给Instance引用变量
      正常是123，但是在多线程下可能132，就会出现问题
  • 如果InStance为null，就说明首次调用，首次调用就需要考虑到线程安全问题，如果非null，就说明是后续的调用，就不必加锁，即双重校验锁。

** volatile**：

  1. 保证内存可见性，每次访问变量都必须重新读取内存，而不会优化到寄存器/缓存中。
  2. 禁止指令重排序，针对这个volatile修饰的变量的读写操作相关指令，是不能被重排序的。
class SingletonLazy {
    // 这个引用指向唯一实例，这个引用先初始化为null，而不是立即创建实例

    // 在这里添加volatile 避免重排序引起的线程安全问题
    private volatile static SingletonLazy instance = null;
    private static Object locker = new Object();

    // 在懒汉模式，有读也有写 instance = new SingletonLazy();,在多线程下是不安全的，且不是单例模式了，
    // 1.通过加锁 synchronized  然后再 把if 和 new两个操作打包成一个原子的
    public static SingletonLazy getInstance() {
        // 2.如果Istance 为null，就说明首次调用，首次调用就需要考虑到线程安全问题
        // 如果非null，就说明是后续的调用，就不必加锁
        // 双重校验锁
        if (instance == null) {
            synchronized (locker) {
                if (instance == null) {
                    instance = new SingletonLazy();// 3.还会出现指令重排序引起线程安全，通过添加volatile解决
                    /**instance = new SingletonLazy(); 拆成三大步骤
                     * 1.申请一段内存空间
                     * 2.在这个内存上调用构造方法，创建出这个实例
                     * 3.把这个内存地址赋值给Instance引用变量
                     * 正常是123，但是在多线程下可能132 就会出现问题
                     */
                }
            }
        }

        return instance;
    }

    private SingletonLazy() {

    }
}
public class ThreadDemo27 {

    public static void main(String[] args) {
        SingletonLazy s1 = SingletonLazy.getInstance();
        SingletonLazy s2 = SingletonLazy.getInstance();
        System.out.println(s1 == s2);
    }
}

2. 阻塞队列

阻塞队列是一种特殊的队列，遵守先进先出的原则。
阻塞队列是一种线程安全的数据结构，包含两个特性：

  • 当队列满的时候，继续入队列就会阻塞，直到有其他线程从队列中取走元素。
  • 当队列空的时候，继续出队列也会阻塞，直到有其他线程往队列中插入元素。

基于阻塞队列，就可以实现 生产消费者模型（是一种多线程编程的方法）。

2.1 引入生产消费者模型的意义：

  1. 解耦合，即把代码的耦合程度，从高降低，在实际开发中，经常涉及到分布式系统，服务器整个功能不是由一个服务器全部完成的，而是每个服务器负责一部分功能，通过服务器之间的网络通信，最终完成整个功能。
    如公网内 的电商网站客户端，获取到主页信息，机房内部网络中 有入口服务器A，用户服务器B，商品服务器C。在这个模型中，A代码就需要涉及到一些和B相关的操作，同样B也涉及A，A和C中的代码也相互涉及。如果B或者C挂了，对A的影响非常大，即为高耦合。
    在这里插入图片描述

引入生产消费者模型之后就可降低耦合，即添加阻塞队列：
在这里插入图片描述上述模型中，A和B、C都不是直接交互了，而是通过阻塞队列传话，如果B或者C挂了，对A的影响几乎没有。

  1. 削峰填谷：如下图模型，当请求多了，A的请求数量会增加很多，B用户服务器（找到对应用户信息）和C商品服务器（从数据库中匹配商品）都会有很大的影响。
    在这里插入图片描述
    添加阻塞队列之后：即使外界的请求出现峰值，队列没有业务逻辑，只是存储数据抗压能力很强。有效的防止了B和C被冲击挂掉。
    在这里插入图片描述

2.2 阻塞队列put方法和take方法

  • put(): put和offer都是入队列，而put带有阻塞功能，没带阻塞功能，队列满了会返回结果。
  • take():取出元素的时候，带有阻塞功能，判定如果队列为空，就进行wait阻塞等待。
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class ThreadDemo28 {
    public static void main(String[] args) throws InterruptedException {
        BlockingQueue<String> queue = new ArrayBlockingQueue<>(100);
        // put和offer都是入队列 ，而 put带有阻塞功能，没带阻塞，队列满了会返回结果
        queue.put("aaa");
        // take 也带有阻塞功能
        String elem = queue.take();
        System.out.println("elem = " + elem);
        elem = queue.take();
        System.out.println("elem = " + elem);
    }
}

2.3 实现阻塞队列–重点

1）先实现普通队列，基于数组来实现（环形队列），区分队列空和队列满：

  1. 浪费一个格子，定义一个head队头和tail队尾，tail最多走到head的前一个位置
  2. 引入size变量

2）再加上线程安全
3）再加上阻塞功能

  • 队列满了，添加wait进行阻塞，队列不满，即出队列成功后进行notify唤醒
  • 队列空了，再出队列，同样也需要阻塞，同样是在另一个入队列成功后的线程中唤醒
class MyBlockingQueue {
    private String[] elems = null;
    private int head = 0;
    private int tail = 0;
    private int size = 0;
    public MyBlockingQueue(int capacity) {
        elems = new String[capacity];
    }

    private Object locker = new Object();
    public void put(String elem) throws InterruptedException {
        synchronized (locker) {
            // 使用while：wait可能会被提前唤醒（当条件还没满足，就被唤醒了）
            while (size >= elems.length) {
                // 队列满了 实现阻塞
                locker.wait(); //在Java标准库推荐使用wait搭配while循环，多一/N次确认操作
            }
            // 如果加锁不包含 while判断队列是否为满，在多线程下就会导致当入队列就会多入一个
            // 新的元素要放到 tail指向的位置上
            elems[tail] = elem;
            tail++;
            // 如果队尾大于数组大小，让tail重新指向0下标，形成闭环
            if (tail >= elems.length) { // tail = tail % elems.length
                tail = 0;
            }
            size++;

            // 入队列成功后进行唤醒
            locker.notify();
        }
    }

    public String take() throws InterruptedException {
        String elem = null;
        synchronized (locker) {
            while (size == 0) {
                //队列空了
                // 实现阻塞
                locker.wait();
            }
            // 取出 head 位置的元素并返回
            elem = elems[head];
            head++;
            if (head >= elems.length) {
                head = 0;
            }
            size--;

            // 队列不满，即出队列成功之后，加上唤醒
            locker.notify();
        }
        return elem;
    }

}
public class ThreadDemo29 {
    public static void main(String[] args) throws InterruptedException {
        MyBlockingQueue queue = new MyBlockingQueue(1000);
        // 生产者消费者模型（核心是阻塞队列,使用synchronized和wait/notify达到线程安全&阻塞） 不仅仅是一个线程
        // 也可能是一个独立的服务器程序，甚至是一组服务器程序
        // 生产者
        Thread t1 = new Thread(() -> {
            int n = 1;
            while (true) {
                try {
                    queue.put(n+" ");
                    System.out.println("生产元素：" + n);
                    n++;
                    //Thread.sleep(500); //生产一个消费一个
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });

        // 消费者
        Thread t2 = new Thread(() -> {
           while (true) {
               try {
                   String n = queue.take();
                   System.out.println("消费元素：" + n);
                   Thread.sleep(500);
               } catch (InterruptedException e) {
                   throw new RuntimeException(e);
               }
           }
        });
        t1.start();
        t2.start();
    }
}

3.定时器

在Java标准库中提供了定时器的使用，Timer类，核心方法是schedule()，它有两个参数，第一个参数是即将执行的任务代码，第二个是指定多长时间之后执行（单位ms）。

3.1 定时器的使用

import java.util.Timer;
import java.util.TimerTask;
// 运行完之后，进程没有结束，因为timer 里内置了线程（前台线程） timer不知道是否还要添加任务进来，
// 可以使用timer.cancel()来主动结束

public class ThreadDemo30 {
    public static void main(String[] args) throws InterruptedException {
        // 定义一个timer添加多任务，每个任务同时会带有一个时间
        Timer timer = new Timer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                //时间到了之后，要执行的代码
                System.out.println("hello timer 3000");
            }
        },3000);

        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("hello timer 2000");
            }
        },2000);

        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("hello timer 1000");
            }
        },1000);

        System.out.println("hello main");
        Thread.sleep(3000);

        timer.cancel();
    }
}

3.2 实现定时器

  • 一个带优先级的阻塞队列（按从小到大的顺序）
  • 队列中的每个元素是一个Task对象
  • Task中带有一个时间属性，队首元素就是即将执行的
  • 同时有一个worker线程一直扫描队首元素，看队首元素是否需要执行
import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.Timer;

// 通过这个类，来描述一个任务
class MyTimerTask implements Comparable<MyTimerTask> {
    //在什么时间点来执行这个任务
    // 此处约定这个time是一个ms 级别的时间戳
    private long time;
    public long getTime() {
        return time;
    }
    // 实际任务要执行的代码
    private Runnable runnable;

    // delay 期望是一个相对时间
    public MyTimerTask(Runnable runnable, long delay) {
        this.runnable = runnable;
        // 计算真正要执行任务的绝对时间（）
        this.time = System.currentTimeMillis() + delay;
    }
    public void run() {
        runnable.run();
    }

    @Override
    public int compareTo(MyTimerTask o) {
        return (int) (this.time - o.time);
    }
}

// 通过这个类，来表示一个定时器
class MyTimer {
    // 负责扫描任务队列，执行任务的线程
    private Thread t = null;
    // 任务队列
    private PriorityQueue<MyTimerTask> queue = new PriorityQueue<>();
    private Object locker = new Object();
    // 把任务放进队列
    public void schedule(Runnable runnable,long delay) {
        synchronized (locker) {
            MyTimerTask task = new MyTimerTask(runnable,delay);
            queue.offer(task);
            // 添加新的元素之后，就可以唤醒扫描线程的wait了
            locker.notify();
        }
    }

    public void cancel() {
        //
    }

    // 构造方法，创建扫描线程，让扫描线程来完成判定和执行
    public MyTimer() {
        t = new Thread(() -> {
            // 扫描线程就需要循环反复的扫描队首元素，然后判定队首元素是不是时间到了
            // 如果没到时间，啥也没有
            // 如果时间到了，就执行这个任务从队列中删除
            while (true) {
                try {
                    // 1. 解决线程安全问题
                    synchronized (locker) { //这里的代码执行速度很快，解锁之后立即又重新尝试加锁，导致
                        // 其他线程通过schedule想加锁，但是加不上 （即线程饿死） -》 引入wait/notify
                        if (queue.isEmpty()) {
                            // 暂时先不处理
                            locker.wait();
                        }
                        MyTimerTask task = queue.peek();
                        // 获取当前时间
                        long curTime = System.currentTimeMillis();
                        if (curTime >= task.getTime()) {
                            //当前时间已经达到了任务时间，就可以执行任务了
                            queue.poll();
                            task.run();
                        }else {
                            // 当前时间还没到任务时间，暂时不执行
                            // 不能使用sleep。会错过新的任务，也无法释放锁
                            //Thread.sleep(task.getTime() - curTime);
                            locker.wait(task.getTime() - curTime);
                        }
                    }  // 释放锁的
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        // 启动线程
        t.start();
    }
}
public class ThreadDemo31 {
    public static void main(String[] args) {
        MyTimer timer = new MyTimer();
        timer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello 3000");
            }
        },3000);
        timer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello 2000");
            }
        },2000);
        timer.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello 1000");
            }
        },1000);
        System.out.println("hello main");
    }
}

4 线程池

线程池：提前把需要用的线程，在线程池里准备好，需要用的时候就从池子里取，用完之后还给池子。
由于频繁的创建销毁进程，成本太高，引入了轻量级 进程，即线程，如果创建销毁线程的频率也进一步提高，此时线程的创建销毁开销也越来越大。
所以有两种优化此处的线程的创建和销毁：

  1. 引入轻量级 线程，即纤程/协程：本质是程序员在用户太代码进行调度，而不是靠内核的调度器调度，节省了调度上的开销。
  2. 线程池：把要使用的线程提前创建好，用完了之后也不要直接释放，而是放进线程池里以备下次使用，从而节省了创建销毁线程的开销。

引入问题：为什么从线程池里取线程就比系统申请更高效？

  • 从线程池里取线程是纯用户态代码（可控的）
  • 通过系统申请创建线程，就是需要内核来完成（不太可控）

4.1 线程池的使用

在Java标准库中，把ThreadPoolExecutor类表线程池，给封装 成 Executors 工厂类，工厂类：创建出不同的线程池对象（在内部把ThreadPoolExecutor创建好了并且设置不同的参数）。
ThreadPoolExecutor 线程池的参数：
在这里插入图片描述

  • int corePoolSize :核心线程数，int maximunmPoolSize：最大线程数
  • long keepAliveTime：保持存活时间，TimeUnit unit:时间单位（s,min,ms,hour）
  • ThreadFactory threadFactor：线程工厂，通过这个工厂类来创建线程对象（Thread）
  • RejectExecutionHandler handler:拒绝策略，在线程池中，有一个阻塞队列，能够容纳的元素有上限，当任务队列已经满了，如果继续往队列添加任务，线程池会进行下面4种操作：

在这里插入图片描述

Executor创建线程池的方式：

  • newFixedThreadPool: 创建固定线程数的线程池
  • newCachedThreadPool: 创建线程数目动态增长的线程池.
  • newSingleThreadExecutor: 创建只包含单个线程的线程池.
  • newScheduledThreadPool: 设定 延迟时间后执行命令，或者定期执行命令. 是进阶版的 Timer.
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadDemo32 {
    public static void main(String[] args) {
        // 创建线程池的时候，设定线程池的线程数量
        ExecutorService service = Executors.newFixedThreadPool(4);
        service.submit(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello");
            }
        });
    }
}

** 创建线程池的时候，很多时候需要设定线程池的线程数量？**

  • 不同的程序，能够设定的线程的数目是不同的，要具体问题具体分析， 一个线程是CPU密集型的任务（在线程run里面进行计算），还是IO密集型任务（在线程run里使用scanner读取用户的输入）
  • 如果一个进程中所有的线程都是CPU密集型的，每个线程所有工作都是CPU上执行，此时线程数目就不应该超过N（CPU的逻辑核心数）。
  • 如果一个进程中，所有线程都是IO密集型，每个线程的大部分工作都是等待IO，此时线程数目与那元超过N
  • 由于程序的复杂性，所以需要通过实验/测试，即设定不同的线程数目，分别进行性能测试，衡量每种线程数目下，总的时间开销，和系统资源占用的开销，找到这之间的合适值。

4.2 实现一个简单的线程池 – 重点

  1. 提供构造方法，指定创建多少个线程
  2. 在构造方法中，把这些线程都创建好
  3. 有一个阻塞队列，能够持有要执行的任务
  4. 提供submit方法，可以添加新的任务
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

class MyThreadPoolExecutor {
    private List<Thread> threadList = new ArrayList<>();

    // 保存任务的队列
    private BlockingQueue<Runnable> queue = new ArrayBlockingQueue<>(1000);
    // 通过n来指定创建多少个线程
    public MyThreadPoolExecutor(int n) {
        for (int i = 0; i < n; i++) {
            Thread t = new Thread(() -> {
               // 线程把任务队列中的任务不停的取出来，并且进行执行
                while (true) {
                    try {
                        // 此处的take 带有阻塞功能
                        // 如果队列为空，此时 take就会阻塞
                        Runnable runnable = queue.take();
                        // 取出一个执行一个
                        runnable.run();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
            t.start();
            threadList.add(t);
        }
    }

    public void submit(Runnable runnable) throws InterruptedException {
        queue.put(runnable);
    }
}

public class ThreadDemo33 {
    public static void main(String[] args) throws InterruptedException {
        MyThreadPoolExecutor executor = new MyThreadPoolExecutor(4);
        for (int i = 0; i < 1000; i++) {
            // n是一个实事final变量 ，每次循环都是一个新的n，就可以被捕获
            int n = i;
            executor.submit(new Runnable() {
                @Override
                public void run() { // 回调函数访问当前外部作用域的变量就是变量捕获
                    // i 一值在变，把i改成成员变量或者 int n = i
                    System.out.println("执行任务" + n + ",当前线程为："+ Thread.currentThread().getName());
                }
            });
        }
    }
}
水冠7
关注
  • 55
    点赞
  • 踩
  • 48
    收藏
    觉得还不错? 一键收藏
  • 19
    评论
专栏目录
笔记16-JAVAEE之多线程进阶
12-17
笔记16-JAVAEE之多线程进阶
javaee-api-8.0-javadoc.jar
10-12
javaee-api-8.0-javadoc.jar，这是javaee1.8api的jar包，解压后可用javadoc2chm制作成chm帮助文档。
JAVAEE----多线程2
m0_58157267的博客
03-25 682
下面我们来讲一下线程的状态 我们之前说进程有就绪状态和阻塞状态,这么说其实是针对一个进程只有一个线程的情况 但其实更常见的情况是---->一个进程中包含多个线程,而所谓的状态,其实也是绑定在线程上的 我们之前说的就绪状态,阻塞状态都是针对系统层面上的线程的状态(PCB) 而在java的Thread类中,对于线程的状态又进一步的细化了 那我们下面就来看看线程状态细化后都分为哪些吧~ 3. 4. 5. 6. 我们小小的整理一下这六种状
JAVAEE---多线程5
m0_58157267的博客
03-31 309
面试常考题 案例三：定时器 这个定时器--->就像一个闹钟，进行定时，在一定时间后被唤醒，并执行某个之前设定好的任务 我们先来介绍标准库的定时器用法 java.util.Timer核心方法就一个----->schedule----->有两个参数：任务是什么；多长时间之后执行 由于Timer内部有专门的线程来负责执行注册的任务的，那么接下来我们来看下Timer内部都需要什么东西吧（共三个） 1.描述任务 创建一个专门的类来表示一个定时器中的任务（TimerTas
JAVAEE---多线程4
m0_58157267的博客
03-28 381
面试中常见问题 案例一:线程安全的单例模式 (单例模式是一种设计模式,设计模式是针对写代码的时候的常见场景给出一些经典解决方案) 单例模式的两种典型实现: 1.饿汉模式 比如:中午这顿饭使用了4个碗,吃完之后,立即把这4个碗洗了 饿汉的单例模式是比较着急的去进行创建实例的 2.懒汉模式(对比饿汉模式,懒汉模式是更加高效的操作) 比如:中午这顿饭使用了4个碗,吃完之后,不全洗,因为晚饭可能只会用到2个碗,因此就只洗2个 懒汉的单例模式是不太着急去创建实例,只有在用的时候,才真正.
【JavaEE】多线程案例-单例模式
不能再留遗憾了的博客
09-13 1066
多线程中常见的案例-单例模式：饿汉模式、懒汉模式实现单例模式，以及解决懒汉模式中出现的线程不安全问题。
JavaEE-多线程初阶3
qq_63983125的博客
12-14 715
volatile , wait , notify , 单例模式
笔记14-JAVAEE之多线程初阶
12-16
1
JavaEE-api.chw
07-08
这是当.CHM的元件（编译的HTML帮助）文件被组合在一起产生一个类型的文件。它节省了合并后的TOC（目录表）和以及包括CHM文件的引用。
JavaEE-8.0-api.zip
12-09
j2ee(JavaEE) 8.0官方api压缩包,使用压缩软件解压后,点击跟目录的index.html可以在网页查看详细的j2ee 8.0的api说明文档
[Java EE] 多线程(六):线程池与定时器
2301_80050796的博客
05-02 1117
我们前面提到,线程的创建要比进程开销小,但是如果线程的创建/销毁比较频繁,开销也会比较大.所以我们便引入了线程池,线程池的作用就是.线程的创建和销毁,需要通过用户态+内核态来配合完成,但是线程池只需要通过用户态即可完成,不需要内核态的配合.举例说明:渣女小故事有一位小姐姐是个渣女,创建和销毁线程就像一位小姐姐和他的男朋友分手了,再和下一位男朋友一点一点培养感情,而线程池就相当于,小姐姐有一个备胎池,他同时和好几个小哥哥培养感情,如果和其中一个分手了,就可以从备胎池中调用其他小哥哥,无缝衔接.
ssm105基于JAVAEE技术校园车辆管理系统+jsp
hjjshua的博客
05-05 854
现代经济快节奏发展以及不断完善升级的信息化技术，让传统数据信息的管理升级为软件存储，归纳，集中处理数据信息的管理方式。本校园车辆管理系统就是在这样的大环境下诞生，其可以帮助管理者在短时间内处理完毕庞大的数据信息，使用这种软件工具可以帮助管理人员提高事务处理效率，达到事半功倍的效果。此校园车辆管理系统利用当下成熟完善的SSM框架，使用跨平台的可开发大型商业网站的Java语言，以及最受欢迎的RDBMS应用软件之一的Mysql数据库进行程序开发。实现了校园车辆基础数据的管理，停车记录查询,停车为查询。
基于Springboot的旅游管理系统（有报告）。Javaee项目，springboot项目。
XING的博客
05-03 1198
基于Springboot的旅游管理系统（有报告）。Javaee项目，springboot项目。数据库作为系统数据储存平台，实现了基于B/S结构的Web系统。界面简洁，操作简单。采用M（model）V（view）C（controller）三层体系结构，通过。
JAVA 学习·泛型（二）——通配泛型
wr114514的博客
05-02 1074
介绍了Java泛型中的重要知识点——通配泛型及其应用。
Java---类和方法的再学习
m0_74012211的博客
05-05 1114
Java类与对象
【Java基础】三大特性——多态
qq_43714449的博客
05-05 407
它的作用是测试它左边的对象是否是它右边的类的实例，返回 boolean 的数据类型。实现一个功能时，功能的一部分是确定的，一部分是不确定，确定的部分还会用到不确定的部分，那么就把不确定的部分暴露出去，让子类去实现。通常通过重写toString方法，来返回有用的数据。instanceof 是 Java 的一个二元操作符，类似于 ==，>，< 等操作符。确定的部分：记录一个开始时间，记录一个结束时间，结束时间 - 开始时间。对类存在的语法，对接口也存在。，返回对象的字符串表示形式。判断两个人是否是同龄人。
Kubernetes基础(二十九)-资源预留
sre救赎之路
05-05 913
如果还设置了对应的 --system-reserved-cgroup 和 --kube-reserved-cgroup参数，Pod能实际使用的资源上限不会改变（即kubepods.limit_in_bytes不变），但系统进程与kube进程也会受到资源上限的限制。比如某个节点的内存的allocatable为10Gi，有三个Pod（requests.memory=3Gi）已经调度到该节点上，那么第4个Pod就无法调度到该节点上，即使该Node上的空闲内存大于3Gi。
如何用Jmeter压测
最新发布
howard1209a的博客
05-06 387
可以从清华源下载，我下的是 5.6.3 版本。bin 目录打开终端，输入 Jmeter 运行Options 点 Choose language 选择中文。
javaee rouyi-vue框架项目
08-26
JavaEE Ruoyi-Vue框架项目是一个基于JavaEE和Vue.js的开发框架。它包含了一系列的子项目，如ruoyi-gateway, ruoyi-auth, ruoyi-system, ruoyi-gen, ruoyi-job等。 这些项目提供了一套完整的解决方案，用于构建企业级的Web应用程序。该框架使用Java语言和Spring Boot作为后端技术，Vue.js作为前端技术。它还包含了一些其他的工具和库，如IDEA集成开发环境和JDK软件等。通过使用这个框架，开发人员可以快速搭建起一个功能强大、易于维护的Web应用程序，并且能够很好地支持JavaEE的特性和Vue.js的前端开发。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [[云原生专题-57]：Kubesphere云治理-操作-RuoYi Cloud项目-Windows单机版安装](https://blog.csdn.net/HiWangWenBing/article/details/122971276)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 19
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值