基于Springboot搭建java项目（十八）——Java线程池原理和运用

news2024/11/16 0:02:56

​ 在上一篇博客中有说到线程的基本原理和用法，其实Java中开辟出了一种管理线程的概念，这个概念叫做线程池，线程池的好处，就是可以方便的管理线程，也可以减少内存的消耗。那么，我们应该如何创建一个线程池？线程池的原理是怎么样的？常见的线程池有哪些呢？

一. 线程池简介

1、线程池的概念：

​ 线程池就是首先创建一些线程，它们的集合称为线程池。使用线程池可以很好地提高性能，线程池在系统启动时即创建大量空闲的线程，程序将一个任务传给线程池，线程池就会启动一条线程来执行这个任务，执行结束以后，该线程并不会死亡，而是再次返回线程池中成为空闲状态，等待执行下一个任务。

2、线程池的工作机制

（1） 在线程池的编程模式下，任务是提交给整个线程池，而不是直接提交给某个线程，线程池在拿到任务后，就在内部寻找是否有空闲的线程，如果有，则将任务交给某个空闲的线程。
（2）一个线程同时只能执行一个任务，但可以同时向一个线程池提交多个任务。

3、使用线程池的原因：

​ 多线程运行时间，系统不断的启动和关闭新线程，成本非常高，会过渡消耗系统资源，以及过渡切换线程的危险，从而可能导致系统资源的崩溃。这时，线程池就是最好的选择了。

二、常用的线程池

1、 ExecutorService

（1）ExecutorService简介

ExecutorService是Java提供的用于管理线程池的接口，这个接口表述了异步执行的机制，并且可以让任务在后台执行。

package com.it520.threadpool;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ExecutorServiceDemo {
	public static void main(String[] args) {
		ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(10);
		newFixedThreadPool.execute(new Runnable() {

			@Override
			public void run() {
				System.out.println("ExecutorServiceDemo.main(...).new Runnable() {...}.run()");				
			}});
		newFixedThreadPool.shutdown();
	}
}

首先使用 newFixedThreadPool() 工厂方法创建一个 ExecutorService ，上述代码创建了一个可以容纳10個线程任务的线程池。其次，向 execute() 方法中传递一个异步的 Runnable 接口的实现，这样做会让 ExecutorService 中的某个线程执行这个Runnable 线程。

（2）任务委托（Task Delegation）

下方展示了一个线程的把任务委托异步执行的ExecutorService的示意图。
在这里插入图片描述

线程把任务委托给 ExecutorService，该线程就会继续执行与运行任务无关的其它任务；

（3）ExecutorService的实现

由于ExecutorService是一个接口，他的实现是需要提供这个接口的实现，ExecutorService 接口在 java.util.concurrent 包中有如下实现类：

  • ThreadPoolExecutor
  • ScheduledThreadPoolExecutor

可以根据自己的需要来创建一个 ExecutorService ，也可以使用 Executors 工厂方法来创建一个 ExecutorService 实例。如下：

ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(10);
ScheduledExecutorService newScheduledThreadPool = Executors.newScheduledThreadPool(10);
ExecutorService newSingleThreadExecutor = Executors.newSingleThreadExecutor();

这也是用也是用常见的四种线程池来创建ExecutorService.

（4）ExecutorService的使用方法

这里有以下几种不同的方式让你将任务委托给ExecutorService：

在这里插入图片描述

下面就对这些方法进行一一讲解

a、execute(Runnable)

方法 execute(Runnable) 接收一个 java.lang.Runnable 对象作为参数，并且以异步的方式执行它。

ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(10);
		newFixedThreadPool.execute(new Runnable() {
			@Override
			public void run() {
				System.out.println("ExecutorServiceDemo.main(...).new Runnable() {...}.run()");				
			}});
		newFixedThreadPool.shutdown();

b、submit(Runnable)

方法 submit(Runnable) 同样接收一个 Runnable 的实现作为参数，但是会返回一个Future 对象。这个 Future 对象可以用于判断 Runnable 是否结束执行

ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
		Future<?> future = newCachedThreadPool.submit(new Runnable() {
			@Override
			public void run() {
				System.out.println("future run");
			}	
		});//如果任务结束执行则返回 null
		System.out.println(future.get());

c、submit(Callable)

方法 submit(Callable) 和方法 submit(Runnable) 比较类似，但是区别则在于它们接收不同的参数类型。Callable 的实例与 Runnable 的实例很类似，但是 Callable 的 call() 方法可以返回一个结果。方法 Runnable.run() 则不能返回结果。

	ScheduledExecutorService newScheduledThreadPool = Executors.newScheduledThreadPool(10);
		Future future2 = newScheduledThreadPool.submit(new Callable<Object>() {

			@Override
			public Object call() throws Exception {
			System.out.println("submit Callable");
				return "Callable Result";
			}
		});
		System.out.println(future2.get());
	}
}

d、inVokeAny()

方法 invokeAny() 接收一个包含 Callable 对象的集合作为参数。调用该方法不会返回 Future 对象，而是返回集合中某一个 Callable 对象的结果，而且无法保证调用之后返回的结果是哪一个Callable，只知道它是这些 Callable 中一个执行结束的 Callable 对象。
如果一个任务运行完毕或者抛出异常，方法会取消其它的 Callable 的执行。

ExecutorService executorService = Executors.newSingleThreadExecutor();
	Set<Callable<String>> callables = new HashSet<Callable<String>>();
	callables.add(new Callable<String>() {
	    public String call() throws Exception {
	        return "Task 1";
	    }
	});
	callables.add(new Callable<String>() {
	    public String call() throws Exception {
	        return "Task 2";
	    }
	});
	callables.add(new Callable<String>() {
	    public String call() throws Exception {
	        return "Task 3";
	    }
	});
	String result = executorService.invokeAny(callables);
	System.out.println("result = " + result);
	executorService.shutdown();

e、invokeAll()

方法 invokeAll() 会调用存在于参数集合中的所有 Callable 对象，并且返回一个包含 Future 对象的集合，你可以通过这個返回的集合来管理每個个Callable 的执行结果。
需要注意的是，任务有可能因为异常而导致运行结束，所以它可能并不是真的成功运行了。但是我们没有办法通过 Future 对象来了解到这个差异。

	ExecutorService executorService = Executors.newSingleThreadExecutor();
	Set<Callable<String>> callables = new HashSet<Callable<String>>();
	callables.add(new Callable<String>() {
	    public String call() throws Exception {
	        return "Task 1";
	    }
	});
	callables.add(new Callable<String>() {
	    public String call() throws Exception {
	        return "Task 2";
	    }
	});
	callables.add(new Callable<String>() {
	    public String call() throws Exception {
	        return "Task 3";
	    }
	});

	List<Future<String>> futures = executorService.invokeAll(callables);
	for(Future<String> future : futures){
	    System.out.println("future.get = " + future.get());
	}
	executorService.shutdown();
	}
}

（5）ExecuteService 服务的关闭

当使用 ExecutorService 完毕之后，我们应该关闭它，这样才能保证线程不会继续保持运行状态。
举例来说，如果你的程序通过 main() 方法启动，并且主线程退出了你的程序，如果你还有一个活动的 ExecutorService 存在于你的程序中，那么程序将会继续保持运行状态。存在于 ExecutorService 中的活动线程会阻止Java虚拟机关闭。
为了关闭在 ExecutorService 中的线程，你需要调用 shutdown() 方法。ExecutorService 并不会马上关闭，而是不再接收新的任务，一但所有的线程结束执行当前任务，ExecutorServie 才会真的关闭。所有在调用 shutdown() 方法之前提交到 ExecutorService 的任务都会执行。
如果你希望立即关闭 ExecutorService，你可以调用 shutdownNow() 方法。这個方法会尝试马上关闭所有正在执行的任务，并且跳过所有已经提交但是还没有运行的任务。但是对于正在执行的任务，是否能够成功关闭它是无法保证的，有可能他们真的被关闭掉了，也有可能它会一直执行到任务结束。这是一个最好的尝试。

关于ExecuteService 的部分知识点转自英文原文链接：http://tutorials.jenkov.com/java-util-concurrent/executorservice.html#executorservice-example ，中文译文首发开源中国社区 http://my.oschina.net/bairrfhoinn/blog/177639

2、ThreadPoolExecutor+BlockingQueue

（1）ThreadPoolExecutor参数

ThreadPoolExecutor构造方法参数如下：

public ThreadPoolExecutor(int corePoolSize,  
                              int maximumPoolSize,  
                              long keepAliveTime,  
                              TimeUnit unit,  
                              BlockingQueue<Runnable> workQueue,  
                              ThreadFactory threadFactory,  
                              RejectedExecutionHandler handler)

a、corePoolSize（线程池的基本大小）：当提交一个任务到线程池时，线程池会创建一个线程来执行任务，即使其他空闲的基本线程能够执行新任务也会创建线程，等到需要执行的任务数大于线程池基本大小时就不再创建。如果调用了线程池的prestartAllCoreThreads方法，线程池会提前创建并启动所有基本线程。

b、workQueue（任务队列）：用于保存等待执行的任务的阻塞队列。可以选择以下几个阻塞队列。

  • ​ ArrayBlockingQueue：是一个基于数组结构的有界阻塞队列，此队列按 FIFO（先进先出）原则对元素进行排序。
  • ​ LinkedBlockingQueue：一个基于链表结构的阻塞队列，此队列按FIFO （先进先出） 排序元素，吞吐量通常要高于ArrayBlockingQueue。静态工厂方法Executors.newFixedThreadPool()使用了这个队列
  • ​ SynchronousQueue：一个不存储元素的阻塞队列。每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量要高于LinkedBlockingQueue。
  • ​ PriorityBlockingQueue：一个具有优先级的无限阻塞队列。

c、maximumPoolSize（线程池最大大小）：线程池允许创建的最大线程数。如果队列满了，并且已创建的线程数小于最大线程数，则线程池会再创建新的线程执行任务。值得注意的是如果使用了无界的任务队列这个参数就没什么效果。

d、ThreadFactory：用于设置创建线程的工厂，可以通过线程工厂给每个创建出来的线程做些更有意义的事情，比如设置daemon和优先级等等

e、RejectedExecutionHandler（饱和策略）：当队列和线程池都满了，说明线程池处于饱和状态，那么必须采取一种策略处理提交的新任务。这个策略默认情况下是AbortPolicy，表示无法处理新任务时抛出异常。以下是JDK1.5提供的四种策略。

  • AbortPolicy：直接抛出异常。
  • CallerRunsPolicy：只用调用者所在线程来运行任务。
  • DiscardOldestPolicy：丢弃队列里最近的一个任务，并执行当前任务。
  • DiscardPolicy：不处理，丢弃掉。

也可以根据应用场景需要来实现RejectedExecutionHandler接口自定义策略。如记录日志或持久化不能处理的任务。

f、keepAliveTime（线程活动保持时间）：线程池的工作线程空闲后，保持存活的时间。所以如果任务很多，并且每个任务执行的时间比较短，可以调大这个时间，提高线程的利用率。

g、TimeUnit（线程活动保持时间的单位）：可选的单位有天（DAYS），小时（HOURS），分钟（MINUTES），毫秒(MILLISECONDS)，微秒(MICROSECONDS, 千分之一毫秒)和毫微秒(NANOSECONDS, 千分之一微秒)。

根据上面的描述，我相信我们能够在熟悉参数的情况下自定义自己的线程池，但是我们发现在jdk帮助文档里面有这样一句话

强烈建议程序员使用较为方便的 Executors 工厂方法 Executors.newCachedThreadPool()（无界线程池，可以进行自动线程回收）、Executors.newFixedThreadPool(int)（固定大小线程池）和Executors.newSingleThreadExecutor()（单个后台线程），它们均为大多数使用场景预定义了设置。

（2）ThreadPoolExecutor执行顺序

a、当currentSize<corePoolSize时，创建线程。

b、当currentSize>=corePoolSize、并且workQueue未满时，将任务放入任务队列。

c、当currentSize>=corePoolSize、workQueue已满

  • 若currentSize<maximumPoolSize，创建线程

  • 若currentSize>maximumPoolSize，抛出RejectExecutionExpection异常，拒绝任务

（3）BlockingQueue

BlockingQueue是一个特殊的队列，当我们从BlockingQueue中取数据时，如果BlockingQueue是空的，
则取数据的操作会进入到阻塞状态，当 BlockingQueue 中有了新数据时，这个取数据的操作又会被重新唤醒。
同理，如果 BlockingQueue 中的数据已经满了，往 BlockingQueue 中存数据的操作又会进入阻塞状态，直到 BlockingQueue 中又有新的空间，存数据的操作又会被重新唤醒。它的泛型限定它是用来存放 Runnable 对象的。
a、几种常用的BlockingQueue

  • ArrayBlockingQueue：

    这个表示一个规定了大小的 BlockingQueue，ArrayBlockingQueue 的构造函数接受一个 int 类型的数据，该数据表示BlockingQueue 的大小，存储在 ArrayBlockingQueue 中的元素按照 FIFO（先进先出）的方式来进行存取。

  • LinkedBlockingQueue：
    这个表示一个大小不确定的 BlockingQueue，在LinkedBlockingQueue 的构造方法中可以传一个 int 类型的数据，这样创建出来的 LinkedBlockingQueue是有大小的，默认LinkedBlockingQueue的大小就为 Integer.MAX_VALUE。

  • PriorityBlockingQueue：
    这个队列和 LinkedBlockingQueue 类似，不同的是PriorityBlockingQueue 中的元素不是按照 FIFO 来排序的，而是按照元素的Comparator 来决定存取顺序的（这个功能也反映了存入 PriorityBlockingQueue 中的数据必须实现了 Comparator 接口）。

  • SynchronousQueue：
    这个是同步 Queue，属于线程安全的 BlockingQueue的一种，在 SynchronousQueue 中，生产者线程的插入操作必须要等待消费者线程的移除操作，Synchronous 内部没有数据缓存空间，因此我们无法对 SynchronousQueue进行读取或者遍历其中的数据，元素只有在你试图取走的时候才有可能存在。我们可以理解为生产者和消费者互相等待，等到对方之后然后再一起离开。

b、常用线程池对应的BlockingQueue

  • newFixedThreadPool()—>LinkedBlockingQueue
  • newSingleThreadExecutor()—>LinkedBlockingQueue
  • newCachedThreadPool()—>SynchronousQueue
  • newScheduledThreadPool()—>DelayedWorkQueue

3、常用线程池

具体的4种常用的线程池实现如下：（返回值都是ExecutorService）

（1）Executors.newFixedThreadPool()

Executors.newFixedThreadPool(int n)：创建一个可重用固定个数的线程池，以共享的无界队列方式来运行这些线程。

package com.it520;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolTest {
    public static void main(String[] args) {
        //创建一个可重用固定个数的线程池
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 6; i++) 
        fixedThreadPool.execute(new Runnable() {
               public void run() {
                   try {
                       //打印正在执行的缓存线程信息
                       System.out.println(Thread.currentThread().getName()+"正在被执行");
                       Thread.sleep(2000);
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
               }
           });
       }
   }

执行结果：

pool-1-thread-2正在被执行
pool-1-thread-3正在被执行
pool-1-thread-1正在被执行
pool-1-thread-2正在被执行
pool-1-thread-1正在被执行
pool-1-thread-3正在被执行

线程池的担心为3，每个线程执行后sleep2秒，这时其他线程进入执行，所以每2秒有三个线程执行输出结果。

（2） Executors.newSingleThreadExecutor()

Executors.newSingleThreadExecutor()：创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolTest {
    public static void main(String[] args) {
        //创建一个单线程化的线程池
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
       for (int i = 0; i < 5; i++) {
           final int index = i;
           singleThreadExecutor.execute(new Runnable() {
               public void run() {
                   try {
                       //结果依次输出，相当于顺序执行各个任务
                       System.out.println(Thread.currentThread().getName()+"正在被执行,打印的值是:"+index);
                       Thread.sleep(1000);
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
               }
           });
       }
   }
}

执行结果：

pool-1-thread-1正在被执行,打印的值是:0
pool-1-thread-1正在被执行,打印的值是:1
pool-1-thread-1正在被执行,打印的值是:2
pool-1-thread-1正在被执行,打印的值是:3
pool-1-thread-1正在被执行,打印的值是:4

（3）Executors.newCachedThreadPool()

Executors.newCacheThreadPool()：可缓存线程池，先查看池中有没有以前建立的线程，如果有，就直接使用。如果没有，就建一个新的线程加入池中，缓存型池子通常用于执行一些生存期很短的异步型任务。

package com.it520;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolTest {
    public static void main(String[] args) {
        //创建一个可缓存线程池
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
       for (int i = 0; i < 5; i++) {
           try {
               //sleep可明显看到使用的是线程池里面以前的线程，没有创建新的线程
               Thread.sleep(1000);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
           cachedThreadPool.execute(new Runnable() {
              public void run() {
                   //打印正在执行的缓存线程信息
                   System.out.println(Thread.currentThread().getName()+"正在被执行");
               }
          });
       }
   }
}

线程池为无限大，当执行当前任务时上一个任务已经完成，会复用执行上一个任务的线程，而不用每次新建线程.

（4）Executors.newScheduledThreadPool()

Executors.newScheduledThreadPool(int n)：创建一个定长线程池，支持定时及周期性任务执行。

延迟执行代码如下：

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ThreadPoolTest {
    public static void main(String[] args) {
        System.out.println("=======");
        //创建一个定长线程池，支持延迟执行
       ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
       //延迟1秒执行
       scheduledThreadPool.schedule(new Runnable() {
           public void run() {
               System.out.println("延迟1秒执行");
           }
       }, 1, TimeUnit.SECONDS);
   }
}

执行结果：

=======
延迟1秒执行

周期性任务执行代码如下：

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ThreadPoolTest {
    public static void main(String[] args) {
        System.out.println("=============");
        //创建一个定长线程池，支持定时及周期性任务执行——定期执行
       ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
       //延迟1秒后每3秒执行一次
       scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
           public void run() {
               System.out.println("延迟1秒后每2秒执行一次");
           }
       }, 1, 2, TimeUnit.SECONDS);
   }
}

执行结果如下：

=============
延迟1秒后每2秒执行一次
延迟1秒后每2秒执行一次
延迟1秒后每2秒执行一次

以上就是关于线程池的一些总结，希望对大家有所帮助。

本文参考一下文档：

https://blog.csdn.net/hnd978142833/article/details/80253784
https://blog.csdn.net/u013541140/article/details/95225769

「DeMonnnnnn」的原创文章。
https://blog.csdn.net/DeMonliuhui/article/details/86477888

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

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

相关文章

JAVASE 基础知识点回顾

JAVASE 基础知识点回顾

1.关键字Static static 有三个特点&#xff0c;这边先阐述一下&#xff0c;后面代码也会展示 static 可以修饰方法(静态方法)、成员变量(静态变量)&#xff0c;修饰不了类请注意&#xff01;随着类的加载而加载&#xff0c;优先于对象存在&#xff0c;说人话就是不new 对象也…
阅读更多...
电机专用SVPWM算法实现

电机专用SVPWM算法实现

SH33F2811包含三相电机的空间矢量脉宽调制&#xff08;Space Vector Pulse Width Modulation&#xff0c;SVPWM&#xff09;算法&#xff0c;对应于交流感应电机或永磁同步电机中的三相电压源逆变器的功率器件的一种特殊的开关触发顺序和脉宽大小的组合。这种开关触发顺序和组合…
阅读更多...
k8s部署 wiki.js ,带中文分词

k8s部署 wiki.js ,带中文分词

官网 https://js.wiki/ https://docs.requarks.io/install/docker-desktop k8s postgres 安装 因为包含中文分词&#xff0c;要在原版的基础上增加分词插件。 这里直接使用别人已经 制作好的镜像 github 地址 : https://github.com/abcfy2/docker_zhparser 镜像地址&#x…
阅读更多...
【 java 集合】Map 接口常用方法总结

【 java 集合】Map 接口常用方法总结

&#x1f4cb; 个人简介 &#x1f496; 作者简介&#xff1a;大家好&#xff0c;我是阿牛&#xff0c;全栈领域优质创作者。&#x1f61c;&#x1f4dd; 个人主页&#xff1a;馆主阿牛&#x1f525;&#x1f389; 支持我&#xff1a;点赞&#x1f44d;收藏⭐️留言&#x1f4d…
阅读更多...
【面试】70道Spring Boot面试题答案

【面试】70道Spring Boot面试题答案

文章目录PartAPartB更多请参考来源PartA 1 什么是springboot &#xff1f; 用来简化spring应用的初始搭建以及开发过程 使用特定的方式来进行配置&#xff08;properties或yml文件&#xff09; 创建独立的spring引用程序 main方法运行 嵌入的Tomcat 无需部署war文件 简化m…
阅读更多...
进程控制【Linux】

进程控制【Linux】

1.进程终止 1.1.进程退出场景 代码运行完毕&#xff0c;结果正确代码运行完毕&#xff0c;结果不正确代码异常终止 1.2.进程常见退出方法 常见的正常中止: 从main函数return返回调用exit_exit 查看进程退出码: echo $?(查看最近一次的进程退出码) 测试代码: include &l…
阅读更多...
【CDP】Cloudera Manager 记录一次 Service Monitor 内存溢出/使用率高的问题及解决方案

【CDP】Cloudera Manager 记录一次 Service Monitor 内存溢出/使用率高的问题及解决方案

一、问题描述 最近发现我们的生产环境 Service Monitor 的监控报表数据无法正常显示&#xff0c;有很多的断点&#xff0c;有很多数据没有被正常采集到&#xff0c;最后定位到是 service monitor 的JVM 内存使用率过高&#xff0c;导致频繁GC&#xff0c;使得 Service Monitor…
阅读更多...
Zynq PL DDR4读写测试工程

Zynq PL DDR4读写测试工程

基于XCZU21DR-2FFVD1156E开发&#xff0c;本文介绍对PL DDR4的读写操作&#xff0c;代码全部经过上板测试。 目录 添加DDR4 IP Basic Mode and Interface & Clocking Controller Options Advanced Clocking VIO IP配置 ILA IP配置 General Options Probe_Ports(0..7…
阅读更多...
爬虫的基本使用

爬虫的基本使用

文章目录urllib库1、基本使用2、一个类型、六个方法3、下载操作4、请求对象的定制5、get请求的quote方法6、get请求的urlencode方法7、post请求百度翻译8、post请求百度翻译之详细翻译小技巧&#xff1a;正则替换9、agax的get请求豆瓣电影第一页**10、agax的get请求豆瓣电影的前…
阅读更多...
使用容器跑一个zabbix 监控另外一个虚机的基础项

使用容器跑一个zabbix 监控另外一个虚机的基础项

目录 安装docker mysql数据库部署 拉取mysql镜像 运行mysql服务器 创建zabbix用户和数据库 进入docker容器登陆数据库 创建zabbix数据库创建zabbix用户 zabbix用户授权 复制mysql初始化数据库文件到容器 导入zabbix初始化数据 zabbix服务器部署 拉取镜像 运行容器 效果…
阅读更多...
Linux环境下，JAVA环境调用C++的动态链接库so

Linux环境下，JAVA环境调用C++的动态链接库so

1、使用QT开发一个动态链接库.so&#xff08;本次使用linux环境&#xff0c;在windows下是.dll&#xff09; 代码文件包含 testdll.cpp testdll.h testdll.pro testdll_global.h testdll.pro #------------------------------------------------- # # Project created by QtC…
阅读更多...
苹果手机怎么清理内存垃圾？2个方法，快速解决

苹果手机怎么清理内存垃圾？2个方法，快速解决

很多小伙伴在生活中会使用手机来看视频、聊天、学习等等。不管是苹果手机还是安卓手机&#xff0c;使用手机的时间长了&#xff0c;里面就会产生很多垃圾占据手机空间。苹果手机怎么清理内存垃圾&#xff1f;今天小编就来分享2个方法&#xff0c;教你快速解决。 一、删除不常用…
阅读更多...
ansible（第五天）

ansible（第五天）

五、实施任务控制 161 1.循环&#xff08;迭代&#xff09;--- loop --item 1.利用loop----item循环迭代任务 with_* 通过循环管理员不需要编写多个使用同一模块的任务。例&#xff1a;他们不需要编写五个任务来确保存在五个用 户&#xff0c;而是只需要编写一个任务来对含有…
阅读更多...
R语言应用xgboost进行机器学习（2）

R语言应用xgboost进行机器学习（2）

XGBoost 机器学习模型是一种高效且可扩的展的机器学习分类器&#xff0c;由 Chen 和 Guestrin 在 2016 年推广。XGBoost原理是是在决策树的基础上产生迭代&#xff0c;它以 boosting 的方式结合了多个决策树。通常创建每棵新树是为了通过梯度提升来减少先前模型的误差&#xff…
阅读更多...
(day4) 自学Java——字符串

(day4) 自学Java——字符串

ctrlaltT 选择语句包裹 目录 1.API 2.String创建 3.字符串的比较 4.字符串——练习 (1):用户登录 (2)遍历字符串和统计字符个数 (3)字符串拼接和反转 (4)金额转换 (5)手机号屏蔽&#xff0c;游戏敏感词替换 5.StringBuilder 6.字符串相关类的底层原理 7.较难练习 …
阅读更多...
苹果手机发热发烫怎么办？常见原因及解决办法

苹果手机发热发烫怎么办？常见原因及解决办法

很多小伙伴都喜欢使用苹果手机&#xff0c;有时候正在玩着苹果手机的时候&#xff0c;发现自己的苹果手机温度很高&#xff0c;很烫手&#xff0c;这是怎么一回事呢&#xff1f;苹果手机发热发烫怎么办&#xff1f;别担心&#xff0c;下面跟着小编一起来看看苹果手机发热发烫常…
阅读更多...
Java之集合概述、ArrayList的使用、常见API和集合案例

Java之集合概述、ArrayList的使用、常见API和集合案例

目录集合概述总结ArrayList集合快速入门总结ArrayList对于泛型的支持总结ArrayList常用API、遍历集合案例遍历并删除元素值总结存储自定义类型的对象元素搜索集合概述 总结 1、数组和集合的元素存储的个数问题? 数组定义后类型确定&#xff0c;长度固定集合类型可以不固定&a…
阅读更多...
MyBatis 动态SQL使用

MyBatis 动态SQL使用

动态 sql 是Mybatis的强⼤特性之⼀&#xff0c;能够完成不同条件下不同的 sql 拼接。 1.<if>标签 运行结果&#xff1a; 2.<trim>标签 之前的插⼊⽤户功能&#xff0c;只是有⼀个 photo 字段可能是选填项&#xff0c;如果有多个字段&#xff0c;⼀般考虑使⽤&l…
阅读更多...
VS Code安装教程

VS Code安装教程

一、下载 1、官网 下载地址 2、下载 根据自己电脑型号下载&#xff0c;此处以Windows为例。 二、安装 1、下载完成后&#xff0c;直接点击安装包安装&#xff0c;即可。 2、开始安装&#xff0c;然后下一步 3、可以在此处自定义地址&#xff0c;然后下一步 4、默认设置&am…
阅读更多...
数据结构课程设计

数据结构课程设计

数据结构课程设计 文章目录数据结构课程设计1.1问题描述1.2需求分析1.3概要设计1.4详细设计1.5调试分析1.6测试结果1.7参考文献1.8源码1.1问题描述 编制一个能演示执行集合的交、并和差运算的程序。 要求&#xff1a; 集合元素用小写英文字母&#xff0c;执行各种操作应以对话…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023