并发和多线程(二)--启动和中断线程(Interrupt)的正确姿势
启动线程:
从一个最基本的面试题开始,启动线程到底是start()还是run()?
Runnable runnable = () -> System.out.println(Thread.currentThread().getName());
Thread thread = new Thread(runnable);
thread.run();
thread.start();
结果:
main
Thread-0
我们可以看到thread.run()是通过main线程执行的,而start()启动的才是一个新线程。run()只是在线程启动的时候进行回调而已,如果没有start(),run()也只是一个普通方法。
start()方法不一定直接启动新线程,而是请求jvm在空闲的时候去启动,由线程调度器决定。
思考题:如果重复执行start()方法会怎样?
Runnable runnable = () -> System.out.println(Thread.currentThread().getName());
Thread thread = new Thread(runnable);
thread.start();
thread.start();
结果:
Exception in thread "main" Thread-0
java.lang.IllegalThreadStateException
at java.lang.Thread.start(Thread.java:705)
at com.diamondshine.Thread.ThreadClass.main(ThreadClass.java:33)
重复执行start()会出现异常,可以从start()的源码得到,因为启动线程的时候,会检测当前线程状态
public synchronized void start() { if (threadStatus != 0) //判断线程启动时的状态是否为new,如果不是,直接抛出异常
throw new IllegalThreadStateException(); group.add(this); boolean started = false;
try {
start0();
started = true;
} finally {
try {
if (!started) {
group.threadStartFailed(this);
}
} catch (Throwable ignore) { }
}
}
PS:关于run()对应Thread和Runnable的区别,请参考上一篇博客并发和多线程(一)--创建线程的方式
线程停止
相比线程启动,线程停止要复杂很多,有些方式虽然可以正常使用,但是可能存在某些风险,也是我们需要深入学习的地方。
1、stop、suspend、resume
这三种方式一般来说不会对我们有影响,因为是已废弃的方法,官方不推荐使用
stop():
废弃的原因,可以查看:https://docs.oracle.com/javase/7/docs/technotes/guides/concurrency/threadPrimitiveDeprecation.html。
PS:stop执行之后,会释放monitor的锁,而不是像某些并发书里面写的不释放锁,参考上面的文档。
suspend和resume:
是配套使用的,suspend本身不释放锁进行休眠,等待resume唤醒,这样很容易满足死锁的条件,所以官方不推荐使用。
2、Interrupt()
我们中断一个线程通常使用Interrupt(),官方废弃stop(),推荐的也是通过Interrupt()实现线程中断。Interrupt()的特点是通知中断线程,而这个线程是否中断选择权在于其本身,这是官方开发人员设计思想:需要被停止的线程可能不是你写的,对其了解可能不够,所以讲是否中断的选择权交于其本身,Interrupt()只是改变中断位的状态。
中断线程的代码书写,取决于线程运行的方式,所以我们可以分类进行分析处理。
2.1).一般情况
一般情况是指,没有调用sleep()、wait()等阻塞状态下的中断。
public static void main(String[] args){
Runnable runnable = () -> {
int num = 0;
while (num <= Integer.MAX_VALUE / 10) {
if (num % 1000 == 0) {
log.info("{}为1000的倍数", num);
}
num++;
}
};
Thread thread = new Thread(runnable);
thread.start();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
thread.interrupt();
}
结果:最后一行
[Thread-0] INFO com.diamondshine.Thread.ThreadClass - 214748000为1000的倍数
从结果上看,interrupt()并没有 让线程停止,因为Integer的最大值2147483647
正确的代码应该是:
public static void main(String[] args){
Runnable runnable = () -> {
int num = 0;
while (!Thread.currentThread().isInterrupted() && num <= Integer.MAX_VALUE / 10) {
if (num % 1000 == 0) {
log.info("{}为1000的倍数", num);
}
num++;
}
};
Thread thread = new Thread(runnable);
thread.start();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
thread.interrupt();
}
结果:最后一行
[Thread-0] INFO com.diamondshine.Thread.ThreadClass - 96540000为1000的倍数
通过结果知道,成功中断了线程。通过isInterrupted()的判断让线程提前中断了,所以interrupt()的作用只是将Interrupted标志位置为true。
2.2).线程处于阻塞状态
public static void main(String[] args) throws InterruptedException{
Runnable runnable = () -> {
int num = 0;
try {
while (!Thread.currentThread().isInterrupted() && num <= 100) {
if (num % 100 == 0) {
log.info("{}为100的倍数", num);
}
num++;
}
Thread.sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
};
Thread thread = new Thread(runnable);
thread.start();
Thread.sleep(5000);
thread.interrupt();
}
结果:
16:24:44.403 [Thread-0] INFO com.diamondshine.Thread.ThreadClass - 942000为1000的倍数
java.lang.InterruptedException: sleep interrupted
at java.lang.Thread.sleep(Native Method)
at com.diamondshine.Thread.ThreadClass.lambda$main$0(ThreadClass.java:28)
at java.lang.Thread.run(Thread.java:745)
主线程sleep休眠5000ms,然后执行interrupt(),而Thread-0只是执行代码时间很短,然后进入sleep,最后出现异常,程序停止运行。所以处于sleep阻塞状态下,可以自动通过抛出异常来相应interrupt(),然后try catch进行捕获异常。
2.3).线程每次迭代都进行阻塞
public static void main(String[] args) throws InterruptedException{
Runnable runnable = () -> {
int num = 0;
try {
while (num <= Integer.MAX_VALUE) {
if (num % 100 == 0) {
log.info("{}为100的倍数", num);
}
num++;
Thread.sleep(1);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
};
Thread thread = new Thread(runnable);
thread.start();
Thread.sleep(500);
thread.interrupt();
}
结果:
20:26:15.870 [Thread-0] INFO com.diamondshine.Thread.ThreadClass - 0为100的倍数
20:26:16.060 [Thread-0] INFO com.diamondshine.Thread.ThreadClass - 100为100的倍数
20:26:16.254 [Thread-0] INFO com.diamondshine.Thread.ThreadClass - 200为100的倍数
java.lang.InterruptedException: sleep interrupted
at java.lang.Thread.sleep(Native Method)
at com.diamondshine.Thread.ThreadClass.lambda$main$0(ThreadClass.java:24)
at java.lang.Thread.run(Thread.java:745)
从上面代码可以看到,在每次迭代都阻塞的场景下,即使没有使用isInterrupted()判断,通过sleep对interrupt()方法做出响应,也可以实现线程中断。
sleep自动清除中断信号
public static void main(String[] args) throws InterruptedException{
Runnable runnable = () -> {
int num = 0;
while (num <= Integer.MAX_VALUE) {
if (num % 100 == 0) {
log.info("{}为100的倍数", num);
}
num++;
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
Thread thread = new Thread(runnable);
thread.start();
Thread.sleep(500);
thread.interrupt();
}
结果:
20:34:40.499 [Thread-0] INFO com.diamondshine.Thread.ThreadClass - 100为100的倍数
20:34:40.701 [Thread-0] INFO com.diamondshine.Thread.ThreadClass - 200为100的倍数
java.lang.InterruptedException: sleep interrupted
at java.lang.Thread.sleep(Native Method)
at com.diamondshine.Thread.ThreadClass.lambda$main$0(ThreadClass.java:24)
at java.lang.Thread.run(Thread.java:745)
20:34:40.897 [Thread-0] INFO com.diamondshine.Thread.ThreadClass - 300为100的倍数
20:34:41.091 [Thread-0] INFO com.diamondshine.Thread.ThreadClass - 400为100的倍数
20:34:41.283 [Thread-0] INFO com.diamondshine.Thread.ThreadClass - 500为100的倍数
我们改变了try catch的位置,发现sleep响应interrupt抛出异常之后,程序继续执行。这是因为抛出的异常被catch住了,但是while循环还是继续的。这种情况下怎么解决呢?尝试在while循环加上对interrupt标志位判断。
public static void main(String[] args) throws InterruptedException{
Runnable runnable = () -> {
int num = 0;
while (!Thread.currentThread().isInterrupted() && num <= Integer.MAX_VALUE) {
if (num % 100 == 0) {
log.info("{}为100的倍数", num);
}
num++;
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
Thread thread = new Thread(runnable);
thread.start();
Thread.sleep(500);
thread.interrupt();
}
结果和上面一样,sleep响应interrupt,但是程序还是继续执行,原因就是因为当线程在sleep过程中相应中断,会自动清除中断标志位,所以这是一种错误的写法。
线程中断的最佳实践
在项目开发中,一般不会像上面直接在Runnable中通过lamdba写逻辑,因为逻辑没有这么简单,可能会在run()中调用方法,这时候就需要注意代码的书写,一般有两种方式。
1、传递中断信息
错误的方式:
private static void doSomething() {
try {
//do something
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
} public static void main(String[] args) throws InterruptedException{
Runnable runnable = () -> {
while (true) {
//do something
System.out.println("continue");
doSomething();
}
};
Thread thread = new Thread(runnable);
thread.start();
Thread.sleep(500);
thread.interrupt();
}
结果:
continue
continue
java.lang.InterruptedException: sleep interrupted
at java.lang.Thread.sleep(Native Method)
at com.diamondshine.Thread.ThreadClass.doSomething(ThreadClass.java:18)
at com.diamondshine.Thread.ThreadClass.lambda$main$0(ThreadClass.java:28)
at java.lang.Thread.run(Thread.java:745)
continue
continue
这种方式,在方法内部吃掉异常,导致外层调用这个方法,无法终止线程。
正确写法:throws向上抛出异常,将interrupt传递出去。
正确做法:
private static void doSomething() throws InterruptedException{
//do something
Thread.sleep(1000);
} public static void main(String[] args) throws InterruptedException{
Runnable runnable = () -> {
try {
while (true) {
//do something
System.out.println("continue");
doSomething();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
};
Thread thread = new Thread(runnable);
thread.start();
Thread.sleep(500);
thread.interrupt();
}
2、恢复中断
如果不想传递中断,就只能采用这种方式,代码如下。
private static void doSomething(){
try {
//do something
Thread.sleep(1000);
} catch (InterruptedException e) {
//在sleep响应中断时候,重新恢复中断信息
Thread.currentThread().interrupt();
e.printStackTrace();
}
} public static void main(String[] args) throws InterruptedException{
Runnable runnable = () -> {
int num = 0;
while (num <= 10000) {
if (!Thread.currentThread().isInterrupted()) {
//do something
System.out.println("continue");
break;
}
doSomething();
num++;
}
};
Thread thread = new Thread(runnable);
thread.start();
Thread.sleep(500);
thread.interrupt();
}
在catch代码块中重新恢复中断信息,然后通过 isInterrupted()判断状态,然后break跳出循环。
我们前面演示了sleep响应中断,除了sleep(),还有很多方法可以做到:
wait()、join()、BlockingQueue.take()/put()、Lock.lockInterruptibly()、CountdownLatch、CyclicBarrier、Exchange、nio。
使用Interrupt的好处:
1、使用interrupt中断线程不是强制性的,相对比较安全。
2、想停止线程,要请求方、被停止方、子方法被调用方相互配合才行。
2.1).请求方:
发出中断信号。
2.2).被停止方:
在合适的时候检查中断信号,并且可能抛出InterrupedException的地方处理该中断信号。
2.3).子方法被调用方:
优先在方法层面抛出InterrupedException,或者检查到中断信号时,再次设置中断状态。
3、volatile实现线程中断
@Slf4j
public class ThreadClass implements Runnable{ //创建volatile修饰的变量
private volatile boolean flag = false; @Override
public void run() {
int num = 0;
try {
while (!flag && num <= 10000) { //通过volatile的可见性实现线程中断
if (num % 100 == 0) {
log.info("{}为100的倍数", num);
}
Thread.sleep(1);
num++;
}
} catch (InterruptedException e) {
e.printStackTrace();
}
} public static void main(String[] args) throws InterruptedException{
ThreadClass threadClass = new ThreadClass();
Thread thread = new Thread(threadClass);
thread.start();
Thread.sleep(500);
threadClass.flag = true;
} }
结果:
13:47:14.660 [Thread-0] INFO com.diamondshine.Thread.ThreadClass - 0为100的倍数
13:47:14.858 [Thread-0] INFO com.diamondshine.Thread.ThreadClass - 100为100的倍数
13:47:15.027 [Thread-0] INFO com.diamondshine.Thread.ThreadClass - 200为100的倍数
从上面结果看,通过volatile的可见性同样实现了线程中断(关于可见性,可以查看JMM和线程安全三大特性相关内容)
volatile实现线程中断的限制
长时间阻塞的场景下,volatile是无法中断线程的,例如使用wait()或者阻塞队列。如果现在有个生产者消费者场景,生产者生产的很快,但是消费者消费速度不够,如果Consumer不需要更多的,请求Producer终止线程,这个场景应该是很有可能出现的。
@Slf4j
public class ThreadClass{ public static void main(String[] args) throws InterruptedException{
ThreadClass threadClass = new ThreadClass();
ArrayBlockingQueue<Object> queue = new ArrayBlockingQueue<>(10);
Producer producer = threadClass.new Producer(queue);
Thread thread = new Thread(producer);
thread.start();
Thread.sleep(1000); Consumer consumer = threadClass.new Consumer(queue);
while (consumer.needMoreNums()) { //通过这个方法模拟需要进行Producer限流
log.info("{}被消费了", consumer.blockingQueue.take());
Thread.sleep(100); //每次消费sleep 100ms,模拟Consumer消费慢的场景
}
System.out.println("消费者不需要更多数据了。"); //一旦消费不需要更多数据了,我们应该让生产者也停下来,但是实际情况
producer.flag=true;
log.info("{}", producer.flag);
// thread.interrupt();
} class Producer implements Runnable{ private volatile boolean flag = false; private ArrayBlockingQueue blockingQueue; public Producer(ArrayBlockingQueue blockingQueue) {
this.blockingQueue = blockingQueue;
} @Override
public void run() {
int num = 0;
try {
while (!flag && num <= 10000) {
if (num % 100 == 0) {
blockingQueue.put(num); //最终Thread-0会被阻塞在这里
log.info("{}被放入生产者队列", num);
}
num++;
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
log.info("生产者运行结束");
}
}
}
class Consumer{ private ArrayBlockingQueue blockingQueue; public Consumer(ArrayBlockingQueue blockingQueue) {
this.blockingQueue = blockingQueue;
} //通过needMoreNums模拟消费者限流的情况
public boolean needMoreNums() {
if (Math.random() > 0.95) {
return false;
}
return true;
}
}
}
生产者-消费者场景-volatile中断线程
结果:
从结果看,Consumer消费太慢,导致Producer阻塞在blockingQueue.put(),这时候无法通过while检测状态,但是interrupt就可以解决这个场景。
@Slf4j
public class ThreadClass{ public static void main(String[] args) throws InterruptedException{
ThreadClass threadClass = new ThreadClass();
ArrayBlockingQueue<Object> queue = new ArrayBlockingQueue<>(10);
Producer producer = threadClass.new Producer(queue);
Thread thread = new Thread(producer);
thread.start();
Thread.sleep(1000); Consumer consumer = threadClass.new Consumer(queue);
while (consumer.needMoreNums()) { //通过这个方法模拟需要进行Producer限流
log.info("{}被消费了", consumer.blockingQueue.take());
Thread.sleep(100); //每次消费sleep 100ms,模拟Consumer消费慢的场景
}
System.out.println("消费者不需要更多数据了。"); //一旦消费不需要更多数据了,我们应该让生产者也停下来,但是实际情况
thread.interrupt(); //通过interrupt中断线程
} class Producer implements Runnable{ private volatile boolean flag = false; private ArrayBlockingQueue blockingQueue; public Producer(ArrayBlockingQueue blockingQueue) {
this.blockingQueue = blockingQueue;
} @Override
public void run() {
int num = 0;
try {
while (!Thread.currentThread().isInterrupted() && num <= 10000) {
if (num % 100 == 0) {
blockingQueue.put(num); //最终Thread-0会被阻塞在这里
log.info("{}被放入生产者队列", num);
}
num++;
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
log.info("生产者运行结束");
}
}
}
class Consumer{ private ArrayBlockingQueue blockingQueue; public Consumer(ArrayBlockingQueue blockingQueue) {
this.blockingQueue = blockingQueue;
} //通过needMoreNums模拟消费者限流的情况
public boolean needMoreNums() {
if (Math.random() > 0.95) {
return false;
}
return true;
}
}
}
生产者-消费者-interrupt中断线程
结果:
14:56:11.562 [main] INFO com.diamondshine.Thread.ThreadClass - 2100被消费了
14:56:11.562 [Thread-0] INFO com.diamondshine.Thread.ThreadClass - 3100被放入生产者队列
java.lang.InterruptedException
at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.reportInterruptAfterWait(AbstractQueuedSynchronizer.java:2014)
at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(AbstractQueuedSynchronizer.java:2048)
at java.util.concurrent.ArrayBlockingQueue.put(ArrayBlockingQueue.java:353)
at com.diamondshine.Thread.ThreadClass$Producer.run(ThreadClass.java:52)
at java.lang.Thread.run(Thread.java:745)
消费者不需要更多数据了。
14:56:11.663 [Thread-0] INFO com.diamondshine.Thread.ThreadClass - 生产者运行结束
jvm设计人员考虑到长时间阻塞的场景,通过interrupt照样可以解决,抛出异常,相应阻塞。这里Thread.currentThread().isInterrupted()替代flag,没有也是可以的,因为是通过抛出异常响应的中断。
总结:
如果我们遇到了线程长时间阻塞(很常见的情况),volatile就没办法及时唤醒它,或者永远都无法唤醒该线程,而interrupt设计之初就是把wait等长期阻塞作为一种特殊情况考虑在内了,我们应该用interrupt思维来停止线程。
interrupt对应的native方法,Thread.sleep() 、lockSupport.park()、 Synchronized同步块、Object.wait()等都可以做出中断相应。
判断中断状态:
interrupted():
static方法,只关注哪个类执行interrupted()这行代码,而和*.interrupted()的这个*没有关系,返回Interrupt状态,但是会把状态位ClearInterrupted置为false,自动清除状态。
isInterruped():
返回Interrupt状态。
public static void main(String[] args) throws InterruptedException{
Thread threadOne = new Thread(() -> {
while (true) { }
}); // 启动线程
threadOne.start();
//设置中断标志
threadOne.interrupt();
//获取中断标志
System.out.println("isInterrupted: " + threadOne.isInterrupted());
//获取中断标志并重置
System.out.println("isInterrupted: " + threadOne.interrupted());
//获取中断标志并重置
System.out.println("isInterrupted: " + Thread.interrupted());
//获取中断标志
System.out.println("isInterrupted: " + threadOne.isInterrupted()); System.out.println("Main thread is over.");
}
isInterrupted: true
isInterrupted: false
isInterrupted: false
isInterrupted: true
Main thread is over.
结果
先思考一下,再看一下结果,和你想的是否一致,如果真的理解了这两个方法,这段代码运行结果应该很容易理解。
思考题:
如何处理不可中断阻塞?
A. 用interrupt方法来请求停止线程
B. 不可中断的阻塞无法处理
C. 根据不同的类调用不同的方法
答案:C
如果线程阻塞是由于调用了 wait(),sleep() 或 join() 方法,可以中断线程,通过抛出InterruptedException异常来唤醒该线程相应阻塞。 对于不能响应InterruptedException的阻塞,并没有一个通用的解决方案。 但是我们可以利用特定的其它的可以响应中断的方法,比如ReentrantLock.lockInterruptibly,比如关闭套接字使线程立即返回等方法来达到目的。因为有很多原因会造成线程阻塞,所以针对不同情况,唤起的方法也不同。
总结:
interrupt这部分内容比较多吧,如果感觉有帮助,需要多想想,下面是基本总结,如果看着这些能想到对应的内容,那说明掌握的不错。
启动线程start()和run()
多次执行start()的结果
停止线程
1、stop、suspend、resume 不推荐
2、interrupt()
多种情况下的中断,一般场景,阻塞状态下,每次遍历都阻塞
sleep、wait等阻塞状态下,对interrupt的响应,而且会直接清除中断信号
最佳实践
1、传递中断
2、恢复中断
3、volatile实现
一般场景可以实现
长时间阻塞,volatile无法实现中断,interrupt可以满足这个场景
判断线程中断的两个方法
interrupted()
isInterruped()
并发和多线程(二)--启动和中断线程(Interrupt)的正确姿势的更多相关文章
- “全栈2019”Java多线程第六章:中断线程interrupt()方法详解
难度 初级 学习时间 10分钟 适合人群 零基础 开发语言 Java 开发环境 JDK v11 IntelliJ IDEA v2018.3 文章原文链接 "全栈2019"Java多 ...
- python 并发专题(二):python线程以及线程池相关以及实现
一 多线程实现 线程模块 - 多线程主要的内容:直接进行多线程操作,线程同步,带队列的多线程: Python3 通过两个标准库 _thread 和 threading 提供对线程的支持. _threa ...
- Java 并发和多线程(二) 多线程的优点 [转]
原文:http://tutorials.jenkov.com/java-concurrency/benefits.html 作者:Jakob Jenkov 翻译:古圣昌 ...
- Java并发编程(二)如何保证线程同时/交替执行
第一篇文章中,我用如何保证线程顺序执行的例子作为Java并发系列的开胃菜.本篇我们依然不会有源码分析,而是用另外两个多线程的例子来引出Java.util.concurrent中的几个并发工具的用法. ...
- 迅雷笔试题 (JAVA多线程)启动三个线程,分别打印A B C,现在写一个程序 循环打印ABCABCABC
题目:http://wenku.baidu.com/view/d66187aad1f34693daef3e8a.html 启动三个线程,分别打印A B C,现在写一个程序 循环打印ABCABCABC. ...
- 中断线程Interrupt()
以下是参考<<Java多线程模式>>的 1. sleep() & interrupt() 线程A正在使用sleep()暂停着: Thread.sleep(100000) ...
- 并发和多线程(二)--线程安全、synchronized、CAS简介
线程安全性: 当多个线程访问一个类的时候,这个类始终表示出正确的行为,那么这个类是线程安全的. 无状态的对象一定是线程安全的,例如大部分service.dao.Servlet都是无状态的. 线程安全体 ...
- Java多线程——<二>将任务交给线程,线程声明及启动
一.任务和线程 <thinking in java>中专门有一小节中对线程和任务两个概念进行了具体的区分,这也恰好说明任务和线程是有区别的. 正如前文所提到的,任务只是一段代码,一段要达成 ...
- Java多线程和并发(十二),Java线程池
目录 1.利用Executors创建线程的五种不同方式 2.为什么要使用线程池 3.Executor的框架 4.J.U.C的三个Executor接口 5.ThreadPoolExecutor 6.线程 ...
随机推荐
- Aizu - ALDS1_13_A-8 Queens Problem-八皇后的路径输出
The goal of Queens Problem is to put eight queens on a chess-board such that none of them threatens ...
- Python3 From Zero——{最初的意识:008~初级实例演练}
一.构显国际橡棋8x8棋盘 #!/usr/bin/env python3 #-*- coding:utf-8 -*- color_0="\033[41m \033[00m" col ...
- python 13 字符编码
转自 http://www.cnblogs.com/BeginMan/p/3166363.html 一.字符编码中ASCII.Unicode和UTF-8的区别 点击阅读:http://www.cnbl ...
- java编程——数据的加法
设计思想: 第一步:从键盘上输入一定个数的整数. 第二步:因为在main()方法中的参数是String类型的,所以第一步中输入的其实是字符类型,在这一步要把String转化成int. 第三步:初始化s ...
- 客户端IAP二次验证
1.首先苹果IAP把每次购买抽象成了一个事务(SKPaymentTransaction), - (void)productsRequest:(SKProductsRequest *)request d ...
- 现代软件工程HW2:结对编程-生成五则运算式-Core10组 [PB16110698+PB16120162]
作业具体要求点 这里 Core组要求: 1.Calc() 这个Calc 函数接受字符串的输入(字符串里就是算术表达式,例如 “5*3.5”,“7/8 - 3/8 ”,“3 + 90 * 0.3”等等) ...
- ARM GNU 常用汇编伪指令介绍
abort .abort: 停止汇编 .align absexpr1, absexpr2: 以某种对齐方式,在未使用的存储区域填充值. 第一个值表示对齐方式,4, 8,16 或 32. 第 二个表 ...
- 【数位DP】CF55D Beautiful numbers
$dp[x][p][pp]$表示第x位,当前已有数字mod 2520(1~9数字的lcm)为p,当前各位数字的lcm为pp 观察到数组太大,考虑压缩,第三维lcm最多只有9个数字,打表发现最多只有48 ...
- 【转载】Delphi异常处理try except语句和try finally语句用法以及区别
Delphi异常处理try except语句和try finally语句用法以及区别 一直写程序都没管他们,也尽量很少用,今天终于想把他给弄个明白,在网上找来,记下!主要是前面小部分,后面的是详细说明 ...
- springMVC 400 错误
1. 今天发现一个奇葩的问题, springMVC出现400错误, 查了很久发现是因为一个参数为int型,而前台传得是String. 这是bug么.