精华内容
下载资源
问答
  • Java如何正确停止线程(三种场景)
    千次阅读
    2020-11-01 15:53:35

    简介

    俗话说:上山容易下山难。知道如何启动线程,那么到底如何停止线程呢?本文将讲解Java中三种场景下如何正确的停止线程,分别是普通情况、堵塞状态、循环中堵塞状态,三种情况下如何正确的停止线程。

    场景一:普通场景下如何停止线程

    如何停止线程:

    我们只能调用线程的interrupt()方法通知系统停止线程,并不能强制停止线程。线程能否停止,何时停止,取决于系统。

    注意

    Java中线程的stop()suspend()resume()三个方法都已经被弃用,所以不再使用stop()方法停止线程。

    1.代码演示

    代码逻辑描述:

    创建一个子线程,子线程汇总循环打印数字。然后我们在其他线程中,调用子线程的interrupt()方法停止线程,观察停止前后的控制台输出情况,理解上述线程停止的含义。

    public class StopNormalThread {
    
    	public static void main(String[] args) throws InterruptedException {
    		// 最好的停止线程方式:通过interrupt通知线程停止线程;而且只能通知,并不能强制让其停止。
    		testInterruptThread();
    
    	}
    
    	/**
    	 * 线程只能通知停止,不能强制立刻停止测试。
    	 */
    	private static void testInterruptThread() throws InterruptedException {
    		Thread thread = new Thread(new Runnable() {
    			public void run() {
    				for (int i = 0; i <= 1000000; i++) {
    					// 判断如果线程没有被中断,则继续输出
    					if (!Thread.currentThread().isInterrupted()) {
    						System.out.println("当前输出位置:" + i);
    					}
    				}
    			}
    		});
    		thread.start();
    		System.out.println("子线程已经启动");
    		//主线程休眠,让子线程跑一会儿,然后让子线程停止
    		Thread.sleep(1000);
    		System.out.println("主线程休眠结束,开始停止子线程");
    		// 终止后,发现for循环还会继续输出内容,少许时间后才停止。说明我们无法控制线程立刻停止。
    		thread.interrupt();
    		System.out.println("子线程已被停止");
    	}
    
    }
    

    程序输出节选:

    子线程已经启动
    当前输出位置:0
    当前输出位置:1
    当前输出位置:2
    略……
    当前输出位置:430290
    当前输出位置:430291
    当前输出位置:430292
    主线程休眠结束,开始停止子线程
    当前输出位置:430293
    当前输出位置:430294
    当前输出位置:430295
    当前输出位置:430296
    当前输出位置:430297
    当前输出位置:430298
    当前输出位置:430299
    当前输出位置:430300
    当前输出位置:430301
    当前输出位置:430302
    当前输出位置:430303
    子线程已被停止
    
    Process finished with exit code 0
    
    

    运行结果解释:

    我们可以看出,子线程创建并启动后,开始输出数字,当主线程中调用thread.interrupt()方法时,即通知系统要停止子线程的运行了,此时控制台中还是会有数字继续输出,这就表明:我们只能通过thread.interrupt()方法通知系统停止子线程,但子线程可能不会立即停止,可能还会继续运行一段时间才会停止。

    场景一:普通场景下通过调用thread.interrupt()方法停止线程

    场景二:堵塞状态下如何停止线程

    什么是堵塞状态:阻塞状态是线程阻塞在进入synchronized关键字修饰的方法或代码块(获取锁)时的状态,即还没有真正运行Synchronized修饰的代码时的状态。BLOCKED或WAITING或TIME_WAITING这三种统称为堵塞状态

    关于线程状态的内容,如不有不明白的地方,可参考:《Java线程状态完全解析教程》

    代码逻辑描述:

    在主线程中创建一个子线程并运行,然后休眠两秒后,让子线程停止。

    在子线程中,循环打印数字,然后让子线程休眠1秒(此时子线程进入阻塞状态),然后子线程会被停止。

    public class StopBlockThread {
    
    	public static void main(String[] args) throws InterruptedException {
    		testBlockingInterruptThread();
    
    	}
    
    	/**
    	 * 中止堵塞状态的线程示例
    	 */
    	private static void testBlockingInterruptThread() {
    		try {
    			Thread thread = new Thread(new Runnable() {
    				public void run() {
    					for (int i = 0; i <= 1000000; i++) {
    						// 判断如果线程没有被中断,则继续输出
    						if (!Thread.currentThread().isInterrupted()) {
    							System.out.println("当前输出位置:" + i);
    						}
    					}
    					try {
    						// 模拟线程堵塞
    						System.out.println("--1--模拟线程堵塞中");
    						Thread.sleep(1000);
    						System.out.println("--2--此行不会被打印,即线程以被停止");
    					} catch (InterruptedException e) {
    						e.printStackTrace();
    					}
    				}
    			});
    			thread.start();
    			System.out.println("让子线程运行两秒,然后再通知其停止");
    			Thread.sleep(2000);
    			/*让子线程for循环在没有循环结束时,接收到停止信号,此时子线程停止,并执行sleep(模拟阻塞状态)时,
    			会抛出sleep interrupted中断异常,表示堵塞状态也被中断了,即堵塞状态的线程成功被终止了 */
    			thread.interrupt();
    			System.out.println("通知停止线程");
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    	}
    
    }
    

    程序输出节选:

    让子线程运行两秒,然后再通知其停止
    当前输出位置:0
    当前输出位置:1
    当前输出位置:2
    略……
    当前输出位置:897419
    当前输出位置:897420
    当前输出位置:897421
    通知停止线程
    --1--模拟线程堵塞中
    java.lang.InterruptedException: sleep interrupted
    	at java.lang.Thread.sleep(Native Method)
    	at thread.stop.StopBlockThread$1.run(StopBlockThread.java:31)
    	at java.lang.Thread.run(Thread.java:748)
    
    Process finished with exit code 0
    

    运行结果解释:

    分析下子线程的运行流程,子线程启动后循环打印数字,打印语句有一个判断条件!Thread.currentThread().isInterrupted(),意思是只要不被中断才打印,若中断了,就不再打印,转而往下执行Thread.sleep(1000)语句,进入堵塞状态。

    此时主线程调用了thread.interrupt(),系统尝试中断子线程,发现子线程在阻塞状态中,所以会抛出异常sleep interrupted,然后我们发现控制台输出Process finished with exit code 0,表示线程被正常停止了。

    场景二:阻塞状态下也可以通过thread.interrupt()停止线程

    场景三:循环中堵塞状态下如何停止线程

    代码逻辑描述:

    主线程中创建一个子线程并运行,两秒钟后,停止子线程。

    子线程run()方法中,写一个循环打印数字逻辑,并在每次循环中,都调用一次Thread.sleep(20),目的是让每次循环都进入堵塞状态。此时要想正常停止线程,必须要在循环外部增加try-catch语句,即当阻塞被停止时,会抛出异常,此时即可终止循环,停止线程

    public class StopLoopBlockThread {
    
    	public static void main(String[] args) {
    		testLoopBlockStopThread();
    	}
    
    	/**
    	 * 循环中存在堵塞的线程停止示例(关键是将循环放到try-catch内部才生效)
    	 */
    	private static void testLoopBlockStopThread() {
    
    		Thread thread = new Thread(new Runnable() {
    			public void run() {
    				try {
    					/* 此处不需要判断线程是否已经被中断了,因为如果在循环中的休眠过程中(堵塞时),
    					 收到interrupt信号,则会立刻抛出停止休眠异常*/
    					for (int i = 0; i < 1000; i++) {
    						System.out.println("当前输出位置:" + i);
    						// 模拟每次循环都堵塞
    						Thread.sleep(20);
    					}
    				} catch (InterruptedException e) {
    					/* try-catch一定放在循环外部,否则线程将不会停止。因为中断异常在循环中被捕获,
    					但循环并没有满足循环停止条件,所以知道循环运行结束,才会停止。即时在循环终止条件中,
    					添加`!Thread.currentThread().isInterrupted()`判断,循环也不会停止,因为线程的sleep()方法,
    					一旦抛出被中断异常后,其isInterrupted标记也会被清除,所以也无法立即停止线程*/
    					e.printStackTrace();
    				}
    			}
    		});
    
    		thread.start();
    		try {
    			Thread.sleep(2000);
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    		thread.interrupt();
    	}
    
    }
    

    程序输出节选:

    当前输出位置:0
    当前输出位置:1
    当前输出位置:2
    当前输出位置:3
    略...
    当前输出位置:95
    当前输出位置:96
    java.lang.InterruptedException: sleep interrupted
    	at java.lang.Thread.sleep(Native Method)
    	at thread.stop.StopLoopBlockThread$1.run(StopLoopBlockThread.java:27)
    	at java.lang.Thread.run(Thread.java:748)
    	
    Process finished with exit code 0
    

    运行结果解释:

    本例最关键地方在于如果仅仅把try-catch语句包裹子线程中的在Thread.sleep(20)上,一旦接收到终止信号,程序开始终止sleep()方法的阻塞状态会抛出异常,此时异常将在循环体内被捕获,循环并不能终止,子线程还是会继续运行,一直运行到for循环结束才能正常停止。这样就不符合我们预期,我们想让程序尽快的做出停止操作,如果程序没有终止,则会造成很多不可挽回的结果。

    场景三:循环中堵塞状态下正确的停止线程,也可以通过thread.interrupt()停止线程,但需要在子线程的循环外部增加try-catch代码块,捕获到中止堵塞状态异常时,也能停止线程。

    总结

    本文介绍了线程在三种场景下的停止方式,都是通过interrupt()方法来停止的,但特殊的是停止循环中的阻塞线程时,需要在循环外部增加try-catch代码块,捕获到中止堵塞状态异常时停止线程。希望这篇文章可以让你掌握如何在多线程编程中,正确的停止线程。喜欢本文请收藏、点赞、关注。

    参考资料补充:
    关于多线程、synchronized关键字wait()notify()方法的系列教程,请参考以下文章:

    《Java线程状态完全解析教程》

    《Java中synchronized实现类锁的两种方式及原理解析》

    《Java中synchronized实现对象锁的两种方式及原理解析》

    《Java多线程wait()和notify()系列方法使用教程》

    《Java多线程中notifyAll()方法使用教程》

    《Java两个线程交替打印奇偶数(两种方法对比)》

    《Java中Synchronized的可重入性和不可中断性的分析和代码验证》

    《Java多线程访问Synchronized同步方法的八种使用场景》

    《Java官方文档创建线程的两种方式及优点和缺点分析》

    《Java中线程安全和线程不安全解析和示例》

    更多相关内容
  • 以全变分去噪模型为基础,详细阐述全变分模型的构造,利用图像的最优关联度作为停止准则的参考,获得一种新型的全变分图像去噪模型。该模型不仅能够获得一种较好的迭代准则,同时,图像去噪后的效果接近最优值。实验结果...
  • 波特率,校验位,数据位,停止位是串口通讯的4个重要的参数。正确设置这几个参数是能正确通讯的前提~ 波特率:波特率是一个衡量传输速度的参数。通俗的讲,波特率就是每秒传多少位。 数据位:衡量通讯中实际数据位的...

    波特率,校验位,数据位,停止位是串口通讯的4个重要的参数。正确设置这几个参数是能正确通讯的前提~

    波特率:波特率是一个衡量传输速度的参数。通俗的讲,波特率就是每秒传多少位。

    数据位:衡量通讯中实际数据位的参数。当计算机发送一个信息包,实际的数据往往不会是8位的,标准的值是6、7和8位。如何设置取决于你想传送的信息。

    停止位:是数据包的最后一位。典型的值为1,1.5和2位。由于数据是在传输线上定时的,并且每一个设备有其自己的时钟,很可能在通信中两台设备间出现了小小的不同步。因此停止位不仅仅是表示传输的结束,并且提供计算机校正时钟同步的机会。适用于停止位的位数越多,不同时钟同步的容忍程度越大,但是数据传输率同时也越慢。

    奇偶校验位:在串口通信中一种简单的检错方式。有四种检错方式:偶、奇、高和低。当然没有校验位也是可以的。对于偶和奇校验的情况,串口会设置校验位(数据位后面的一位),用一个值确保传输的数据有偶个或者奇个逻辑高位。例如,如果数据是011110,那么对于偶校验,校验位为0,保证逻辑高的位数是偶数个。如果是奇校验,校验位为1,这样就有3个逻辑高位。高位和低位不是真正的检查数据,简单置位逻辑高或者逻辑低校验。这样使得接收设备能够知道一个位的状态,有机会判断是否有噪声干扰了通信或者是否传输和接收数据是否不同步。

    厂家串口调试助手设置界面:
    在这里插入图片描述

    展开全文
  • 停止等待协议

    千次阅读 2020-03-19 11:20:42
    1,为什么要有停止等待协议? 2,研究停等协议的前提? “停止-等待”就是发送完一个分组就停止发送,等待对方确认,在收到确认后再发送下一个分组。 停等协议--无差错情况: 停等协议--有差错情况: 1,...

    1,为什么要有停止等待协议?

    2,研究停等协议的前提?

    “停止-等待”就是发送完一个分组就停止发送,等待对方确认,在收到确认后再发送下一个分组。

    停等协议--无差错情况:

    停等协议--有差错情况:

    1,数据帧丢失或检测到帧出错:

    2,ACK丢失:

    3,ACK迟到:

    停等协议性能分析:

    信道利用率:

    展开全文
  • Linux进程生命周期(就绪、运行、睡眠、停止、僵尸) 僵尸的含义 停止状态与作业控制, cpulimit 内存泄漏的真实含义 task_struct以及task_struct之间的关系 初见fork和僵尸 1、进程控制块PCB Task_struct ...
    • 学习交流加(可免费帮忙下载CSDN资源):
    • 个人微信: liu1126137994
    • 学习交流资源分享qq群1(已满): 962535112
    • 学习交流资源分享qq群2: 780902027

    本篇文章主要记录以下学习内容:

    • Linux进程生命周期(就绪、运行、睡眠、停止、僵尸)
    • 僵尸的含义
    • 停止状态与作业控制, cpulimit
    • 内存泄漏的真实含义
    • task_struct以及task_struct之间的关系
    • 初见fork和僵尸

    1、进程控制块PCB

    Task_struct (PCB) 通俗一点的说就是描述进程资源的结构体,也可以称为进程描述符。在这个结构体中存放着这个进程所需要的所有资源的结构的描述。例如我们能想到的进程肯定有进程id,进程的内存管理,对文件的管理,对信号的管理等,那么PCB中就肯定存有类似于下面的结构:

    在这里插入图片描述

    其中PID的数量是有限的,在我自己的Linux系统中是32768

    $ cat /proc/sys/kernel/pid_max
    32768
    
    所以我们不能无限制的创建进程。

    那么在Linux中Task_struct是如何被管理的呢?

    1. 形成链表

    在这里插入图片描述

    1. 形成树
      因为链表遍历的开销比较大,所以会在链表的基础上,形成树结构,这样会使对进程描述符的遍历的时间复杂度更低
      在这里插入图片描述

    2. 形成哈希 :pid->task_struct
      为了更加快捷的访问到进程描述符,可以让进程的pid作为索引,形成哈希结构,这样在实现进程的调度算法时,效率会更高效。

    在这里插入图片描述

    2、进程的生命周期

    在这里插入图片描述

    上图表示了进程的六种状态,就绪态,运行态,深度睡眠态,浅睡眠态,停止态,僵尸态。

    就绪态和运行态在数值上是相等的,都是由宏TASK_RUNNING定义。就绪态和运行太可以相互转换,运行态可以到停止态(例如ctrl+z),停止态可以恢复到就绪态。

    其中,就绪态,运行态,停止态很好理解,这里不再赘述。

    • 深睡眠
      进程处于睡眠态(调用sleep),等到资源到位,就可以被调度(变成就绪态TASK_RUNNING)。
    • 浅睡眠
      进程处于睡眠态(调用sleep),等到资源到位,或者收到信号,就可以被调度(变成就绪态TASK_RUNNING)。

    正常的进程睡眠都是浅睡眠,但是内核中有一些进程处于睡眠态不希望被信号打断,那么它就会处于深睡眠状态。

    • 僵尸态
      资源已经释放,没有内存泄漏等!!!
      但是 Task_struct还在,这样的话,父进程可以根据子进程的Task_struct结构体存的退出码,查出子进程的死因。

    有内核代码如下:
    在这里插入图片描述

    3、作业控制(cpulimit)

    有时候我们的进程的CPU占用率非常高,为了使其他进程可以获得CPU时间,我们可以使用一些手段降低进程的CPU占用率。

    其中cpulimit是之前比较常用的一个命令,它利用间断性的使进程处于停止态,从而降低进程的CPU占有率。

    假设我的进程是一个死循环,且CPU占有率很高,则通过以下命令可以降低该使进程号为10111的进程的CPU占有率变为20%。

    $ cpulimit -l 20 -p 10111
    

    cpulimit的原理:
    在这里插入图片描述

    4、内存泄漏到底是什么

    • 内存泄漏不是进程死了内存没释放

    如果进程死了(退出或者变成僵尸),它所占有的内存资源会瞬间全部释放。
    在这里插入图片描述

    • 内存泄漏是进程活着,但随着时间的推移,内存消耗越来越多

    在这里插入图片描述

    5、初见fork

    1. 初识fork

    看下面程序打印几个hello?

    int main() {
    	fork();
    	printf("hello\n");
    	fork();
    	printf("hello\n");
    	while (1);
    	return 0;
    }
    

    在这里插入图片描述

    假设p1是main函数这个进程,进入函数后,fork产生一个子进程p2,p1和p2各打印一个hello,接着p1和p2又各fork(),分别又产生两个hello,所以一共打印6个hello。

    运行下面程序看如何打印:

    #include <stdio.h>
    #include <sys/wait.h>
    #include <stdlib.h>
    #include <unistd.h>
    
    int main(){
        pid_t pid;
    
        pid = fork();
    
        if(pid==-1){ /* 创建不成功 */
            perror("Can't creat new process");
            exit(1);
        }
        else if(pid==0){  /* pid==0,子进程运行代码 */
            printf("a\n");
        }
        else {     /* 父进程运行代码 */
            printf("b\n");
        }
    	/* 父子进程都运行的代码 */
        printf("c\n");
        while(1);
    }
    
    

    运行结果为:
    在这里插入图片描述

    • 结果分析:

    fork()函数的返回值是返回两次的,在父进程中返回子进程的pid,在子进程中返回0。借此我们可以在代码中区分开父子进程运行的代码。

    进入函数后首先fork(),产生一个子进程,在子进程的进程空间的环境创建好之前,父进程就已经运行完并打印了b和c,然后子进程打印a和c。

    2. 子死父清场(life_period.c)

    #include <stdio.h>
    #include <sys/wait.h>
    #include <stdlib.h>
    #include <unistd.h>
    
    int main(void)
    {
    	pid_t pid,wait_pid;
    	int status;
    
    	pid = fork();
    
    	if (pid==-1)	{
    		perror("Cannot create new process");
    		exit(1);
    	} else 	if (pid==0) {
    		printf("child process id: %ld\n", (long) getpid());
    		pause();
    		_exit(0);
    	} else {
    #if 1 /* define 1 to make child process always a zomie */
    		printf("ppid:%d\n", getpid());
    		while(1);
    #endif
    		do {
    			wait_pid=waitpid(pid, &status, WUNTRACED | WCONTINUED);
    
    			if (wait_pid == -1) {
    				perror("cannot using waitpid function");
    				exit(1);
    			}
    
    			if (WIFEXITED(status))
    				printf("child process exites, status=%d\n", WEXITSTATUS(status));
    
    			if(WIFSIGNALED(status))
    				printf("child process is killed by signal %d\n", WTERMSIG(status));
    
    			if (WIFSTOPPED(status))
    				printf("child process is stopped by signal %d\n", WSTOPSIG(status));
    
    			if (WIFCONTINUED(status))
    				printf("child process resume running....\n");
    
    		} while (!WIFEXITED(status) && !WIFSIGNALED(status));
    
    		exit(0);
    	}
    }
    
    • 在if 1不改为if 0的情况下

    编译运行程序,杀死子进程,查看父进程的僵尸态

    编译运行:

    $ gcc life_period.c
    $ ./a.out
    Child process id:6426
    

    另开一个终端先看父子进程的状态:
    在这里插入图片描述
    然后杀死子进程:

    $ kill -9 6426
    

    再查看状态:
    在这里插入图片描述
    可以看到,子进程(pid=6426)的状态已经变味僵尸态

    • 在if 1改为if 0的情况下

    编译运行程序,杀死子进程,查看父进程的僵尸态

    编译运行:

    $ gcc life_period.c
    $ ./a.out
    Child process id:6430
    

    另开一个终端先看父子进程的状态:
    在这里插入图片描述

    然后杀死子进程

    $ kill -9 6430
    

    在第一个终端可以看到子进程被杀死的原因
    在这里插入图片描述
    然后父进程也退出。

    可以看出父进程可以通过waitpid()函数回收子进程的task_struct结构。

    6、总结

    • 理解Linux进程的生命周期(六种状态)
    • 理解task_struct结构
    • 理解僵尸进程(资源已经释放,Task_struct结构还在)
    • 理解内存泄漏的真实含义
    • 理解fork与僵尸态
    • 动手写上述实验代码并自己编译运行

    学习探讨加:
    个人微信:liu1126137994
    个人qq :1126137994

    展开全文
  • ElasticSearch启动&停止命令

    千次阅读 2022-04-18 09:31:36
    停止命令 ElasticSearch启动&停止命令 1、查进程 2、杀进程 3、启动服务 4、 jps 命令查看运行状态 ElasticSearch启动&停止命令 1、查进程 ps -ef|grep elastic 2、杀进程 kill -9 1302 ps -ef|grep...
  • ABB机器人的几种停止指令详解

    万次阅读 2020-01-26 12:25:23
    比如上一次我们一起分享的ABB机器人安全回路中的ES与AS,通过示教器的停止键或者系统输入中的stop来停止机器人,还有就是可以通过ABB机器人中的各种停止指令使机器人在满足某种条件的时候自行停止。这一次我们就来...
  • 最近发现一个问题,ps命令输出里面进程状态为S+的含义,网上好多文章都说是表明进程“位于在后台进程组”。 例如下面这个ps命令输出说明: D 不可中断 Uninterruptible sleep (usually IO) R 正在运行,或在队列中...
  • 2.七个方法的含义 一、 onCreate :当活动第一次启动的时候,触发该方法,可以在此时完成活动的初始化工作。 二、 onStart :该方法的触发表示所属活动将被展现给用户,可视化。 三、 onResume :当一个活动和用户...
  • oracle服务启动停止方法有什么?

    千次阅读 2021-05-01 05:09:56
    Oracle9I开始,取消了服务器管理器(svrmgl)和internal用户,数据库的启动和停止都是通过sql*plus来完成! Oracle10g可以通过浏览器来启动和停止数据库服务!这里主要说说9I下的启动和停止服务,下面的命令在8i下也可以...
  • 如何停止定时任务@Scheduled

    千次阅读 热门讨论 2020-09-12 09:51:05
    @Scheduled 定时任务可配置的表达式有 cron、zone、fixedDelay、fixedRate、initialDelay 等,当定时任务满足某个条件时,我们想停止它,修改代码显然是不适宜的办法,怎么办呢? 一、如果类中只有一个定时任务,...
  • [整理]kill -9的含义

    千次阅读 2021-05-18 10:47:12
    折腾:期间,看到一个:kill -9需要去搞懂对应含义。搜:kill 9 meaningName Num Action DescriptionKILL 9 exit cannot be blockedThe command kill sends the specified signal to the specified process or ...
  • 前言:在学习tcp三次握手的过程之中,由于一直无法解释tcpdump命令抓的包中seq和ack的含义,就将tcp协议往深入的了解了一下,了解到了几个协议,做一个小结. 一:停止等待协议 停止等待协议是tcp保证传输可靠的重要途径,”...
  • 算法的含义与描述 典例分析 题型一算法的含义 例?1?下面对算法描述正确的一项是 A算法只能用自然语言来描述 B算法只能用图形方式来表示 C同一问题可以有不同的算法 D同一问题的算法不同结果必然不同 例?2?关于算法的...
  • 接触SpringBoot项目之后,一直就没弄清楚到底如何正确的启动、停止Jar包,只知道简单 java -jar demo.jar命令, 遇到过好多问题,比如在linux服务器上启动成功后“终端窗口”关闭了或ctrl+c退出后服务就没了;...
  • double vec = ((m_game->startpos-endPos)*4).length(); /* char Info[24]; sprintf(Info,"%0.2f",sqrt(vec)); m_lable->setText(QString(Info));*/ ... double vec = ((m_game->startpo...
  • 调试Qt程序的时候,出现“底层由于接收到操作系统的信号而停止”。信号名称:SIGSEGV信号意义:Segmentation fault这类现象都是因为内存错误导致的。分析一:内存未申请成功,却使用了它。对策: 在使用指针前,用Q_...
  • Linux命令:Nginx的启动、停止与重启

    千次阅读 2020-03-13 18:43:25
    2.停止 首先查看nginx进程号 ps -ef|grep nginx 然后有几种方式可杀死进程号,如: kill -9 进程号 kill不同数字代表不同含义 3.重启 首先cd进nginx可执行目录sbin下,然后 ./nginx -s reload ...
  • 在所有最优停止问题中,最大的难点不在于选择哪一种可选方案,而是确定自己需要考虑多少种可选方案。这些问题往往会引发不同的后果,不仅陷入爱河的人和需要租房的人必须慎重考虑,司机、房主、入室行窃者等也常常...
  • - 我什么时候应该停止训练? https://github.com/AlexeyAB/darknet Usually sufficient 2000 iterations for each class (object), but not less than 4000 iterations in total. But for a more precise ...
  • 解决方法,就是添加一个 : autoplayDisableOnInteraction:false, 具体参数的含义,可查阅swiper 官方文档: 关于swiper自动轮播的图片,加了autoplay 属性/但是当用户操作swiper之后,默认会停止自动轮播。...
  • linux 各个SIG信号含义

    千次阅读 2019-04-24 09:05:31
    很有用的sig信号含义说明 转发自 :https://blog.csdn.net/tennysonsky/article/details/46010505 在 Linux 下,每个信号的名字都以字符 SIG 开头,每个信号和一个数字编码相对应,在头文件 signum.h 中,这些信号...
  • 具体参数的含义,可查阅swiper 官方文档 关于swiper自动轮播的图片,加了 autoplay 属性/但是当用户操作swiper之后,默认会停止自动轮播 。 autoplayDisableOnInteraction 默认为true:停止。 如果设置为false,用户...
  • linux信号及其含义

    千次阅读 2017-05-08 20:07:56
    SIGSTOP 停止进程 非终端来的停止信号 SIGTSTP 停止进程 终端来的停止信号 SIGCONT 忽略信号 继续执行一个停止的进程 SIGURG 忽略信号 I/O紧急信号 SIGIO 忽略信号 描述符上可以进行I/O SIGCHLD 忽略信号 ...
  • Distinct:MySQL发现第1个匹配行后,停止为当前的行组合搜索更多的行。 Not exists:MySQL能够对查询进行LEFT JOIN优化,发现1个匹配LEFT JOIN标准的行后,不再为前面的的行组合在该表内检查更多的行。 range ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 161,136
精华内容 64,454
关键字:

停止含义