执行throw后 后面代码还会执行吗?

1.当我们对throw的对象进行try catch之后
public void re(int i) {
        if (i > 5){
            this.i = i;
        }else {
            try {
                throw new Exception("数据非法!");
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println("123");
        }
结果显示:123被输出
java.lang.Exception: 数据非法!
	at com.zsxfa.java.Ex3.re(ExcTest1.java:21)
	at com.zsxfa.java.ExcTest1.main(ExcTest1.java:10)
123
2 不对throw的对象进行try catch操作
  • 2.1
public void re(int i) throws Exception {
        if (i > 5) {
            this.i = i;
        }else {
            throw new Exception("数据非法!");
            System.out.println("123");  
        }
结果显示:编译不通过
  • 2.2
public void re(int i) throws Exception {
        if (i > 5) {
            this.i = i;
        }else {
            throw new Exception("数据非法!");
        }
        System.out.println("123");
结果显示:异常抛出,123不会输出
java.lang.Exception: 数据非法!
	at com.zsxfa.java.Ex2.re(ExcTest.java:30)
	at com.zsxfa.java.ExcTest.main(ExcTest.java:11)
数据非法!

拓展

		try{
			return;
		}catch(){
			
		}finally{
		
		}
		return;

上面的代码的执行顺序是这样的:

代码段首先进入try语句,因无异常抛出,代码将要return的内容保存在内存中,然后执行finally,因finally中无可执行内容,再转回try中执行return,整个代码段执行结束,而finally后面的return是不会执行的。

1、不管有没有出现异常,finally块中代码都会执行;

2、当try和catch中有return时,finally仍然会执行;

3、finally是在return后面的表达式运算后执行的(此时并没有返回运算后的值,
而是先把要返回的值保存起来,不管finally中的代码怎么样,返回的值都不会改
变,仍然是之前保存的值),所以函数返回值是在finally执行前确定的;

4、finally中最好不要包含return,否则程序会提前退出,返回值不是try或catch中保存的返回值。
  • 11
    点赞
  • 26
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java学习的笔记,回顾一些基本的要领,知识点,很有帮助 比如: Day Eight 异常: 异常的分类 Java会将所有的异常封装成对象,其根本父类为Throwable。 Throwable有两个子类:Error 和Exception。 Error:一个Error对象表示一个程序错误,指的是底层的低级的不可恢复的严重错误 遇到Error,程序一定会退出,因为已经失去了运行所必须的物理环境。 对于Error我们无法进行处理,因为我们是通过程序来应对错误的,可是程序已经退出了。 Exception:由特定因素,导致程序无法继续,但不影响虚拟机的正常执行。 未检查异常(Runtime Exception): 是因为程序员没有进行必要的检查,由于程序员的疏忽而引起的异常。 对于未检查异常可以不处理,编译可以通过,应对未检查异常的方法就是养成良好的检查习惯 已检查异常(非Runtime Exception): 是不可避免的,对于已检查异常必须处理,否则编译不通过。 异常处理的机制: 当一个方法中有一条语句出现了异常,它就会throw(抛出)一个异常对象(throw 异常对象),然后后面的语句不会执行,而返回上一级方法,其上一级方法接受到了异常对象之后,有可能对这个异常进行处理(进行处理则不会上抛),也可能将这个异常传到它的上一级,如果最上一级(main方法)不处理就会传给虚拟机,虚拟机就会终止程序的运行。 异常的处理方式:throws和try-catch方法 try-catch处理方式: try{ //一个 (1)可能出现异常的语句 } catch(XxxException e /*捕获的异常*/){ //0或n个 (2)处理异常的代码 } finally{ //0或1个 (3)必须要执行代码 } (4)方法中的其他代码 如果代码正确,那么程序不经过catch语句直接向下运行; 如果代码不正确,则将返回的异常对象和e进行匹配,如果匹配成功,则处理后面的异常处理代码。 try中如果发现错误,即跳出try块去匹配catch,那么try后面的语句就不会被执行。 一个try可以跟多个catch语句,用于处理不同情况,但是不能将父类型的exception的位置写在子类型的excepiton之前。 在try-catch后还可以再跟一子句finally。其中的代码语句论有没有异常都会被执行(因为finally子句的这个特性,所以一般将释放资源,关闭连接的语句写在里面)。 finally中的代码和try-catch中的代码冲突时,finally中的代码一定会被执行且会忽略try-catch中的代码。但是如果try-catch中有System.exit(0);(虚拟机退出语句),则不会去执行fianlly中的代码
Excel POI读取封装(文件+示范代码) package org.excel.service; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileWriter; import java.io.IOException; import java.lang.reflect.Field; import java.sql.Connection; import java.sql.DriverManager; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; import java.text.DateFormat; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.*; import javax.jws.WebService; import org.apache.poi.hssf.usermodel.*; import org.excel.data.DataType; import org.excel.data.DealForeign; import org.excel.data.ExcelImport; import org.excel.data.impl.StInStatusImpl; import org.excel.data.impl.StuClassImportImpl; import org.excel.data.impl.StuEducationImpl; import org.excel.data.impl.StuImprotDataImpl; import org.excel.data.impl.StuInClassImportImpl; import org.excel.data.impl.StuWorkStatusImpl; import org.excel.manager.Util; import org.excel.model.ExcelMap; import org.excel.xml.ExcelXmlParse; import net.sourceforge.jtds.jdbcx.JtdsDataSource; @WebService public class ExcelServiceImpl implements IExcelService { String tableName = ""; public static Integer suc = 0; public static Integer fail = 0; StringBuilder insert = new StringBuilder( " insert into {tableName} {column} values {values}"); /** 读取Excel表格数据 */ public List<HashMap> readExcel(String excelName, Integer sheetIndex, String startPoint, String endPoint) throws Exception { FileInputStream inputStream = null; inputStream = new FileInputStream(excelName); HSSFWorkbook workbook = new HSSFWorkbook(inputStream); HSSFSheet sheet = workbook.getSheetAt(sheetIndex); String[] sc = null;// 开始坐标 String[] ec = null;// 结束坐标 int startRow = 0;// 默认开始行数 int endRoe = sheet.getPhysicalNumberOfRows();// 默认结束行 int startLine = 0;// 默认开始列 int endLine = 0;// 结束列 if (startPoint != null && endPoint != null) { sc = startPoint.
线程安全,并发的知识有加深认知;当然,现在用过的东西并不是代表以后还能娴熟的使用,做好笔记非常重要; 1:必须明白为什么要使用线程池:(这点很重要)   a:手上项目所需,因为项目主要的目的是实现多线程的数据推送;需要创建多线程的话,那就要处理好线程安全的问题;因为项目需要,还涉及到排队下载的功能,所以就选择了线程池来管理线程以及线程池里面的任务队列workQueue来实现项目所需的功能;   b:在实际使用中,服务器在创建和销毁线程上花费的时间和消耗的系统资源都相当大,甚至可能要比在处理实际的用户请求的时间和资源要多的多。除了创建和销毁线程的开销之外,活动的线程也需要消耗系统资源。如果在一个jvm里创建太多的线程,可能会使系统由于过度消耗内存或“切换过度”而导致系统资源不足。为了防止资源不足,服务器应用程序需要采取一些办法来限制任何给定时刻处理的请求数目,尽可能减少创建和销毁线程的次数,特别是一些资源耗费比较大的线程的创建和销毁,尽量利用已有对象来进行服务,这就是“池化资源”技术产生的原因。 线程池主要用来解决线程生命周期开销问题和资源不足问题(这段是摘自网络) 2:如何创建一个线程池:    复制代码 public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler) { if (corePoolSize < 0 || maximumPoolSize <= 0 || maximumPoolSize < corePoolSize || keepAliveTime < 0) throw new IllegalArgumentException(); if (workQueue == null || threadFactory == null || handler == null) throw new NullPointerException(); this.corePoolSize = corePoolSize; this.maximumPoolSize = maximumPoolSize; this.workQueue = workQueue; this.keepAliveTime = unit.toNanos(keepAliveTime); this.threadFactory = threadFactory; this.handler = handler; } 复制代码 这里只是创建线程池其中的一个构造函数;其实其他的构造函数最终还是调用的这个构造函数; 说明一下这些参数的作用: corePoolSize:核心池的大小,在创建了线程池后,线程池中的线程数为0,当有任务来之后,就会创建一个线程去执行任务,当线程池中的线程数目达到corePoolSize后,就会把到达的任务放到缓存队列当中; maximumPoolSize:线程池最大线程数,它表示在线程池中最多能创建多少个线程;这个参数是跟后面的阻塞队列联系紧密的;只有当阻塞队列满了,如果还有任务添加到线程池的话,会尝试new 一个Thread的进行救急处理,立马执行对应的runnable任务;如果继续添加任务到线程池,且线程池中的线程数已经达到了maximumPoolSize,那么线程就会就会执行reject操作(这里后面会提及到) keepAliveTime:表示线程没有任务执行时最多保持多久时间会终止;默认情况下,只有当线程池中的线程数大于corePoolSize时,keepAliveTime才会起作用;即当线程池中的线程数大于corePoolSize时,如果一个线程空闲的时间达到keepAliveTime,则会终止,直到线程池中的线程数不超过corePoolSize。但是如果调用了allowCoreThreadTimeOut(boolean)方法并设置了参数为true,在线程池中的线程数不大于corePoolSize时,keepAliveTime参数也会起作用,直到线程池中的阻塞队列大小为0;(这部分通过查看ThreadPoolExecutor的源码分析--getTask()部分); unit:参数keepAliveTime的时间单位,有7种取值,在TimeUnit类中有7种静态属性(时间单位) workQueue:一个阻塞队列,用来存储等待执行的任务,这个参数的选择也很重要,会对线程池的运行过程产生重大影响,一般来说,这里的阻塞队列有以下几种选择     ArrayBlockingQueue;   LinkedBlockingQueue;   SynchronousQueue;   ArrayBlockingQueue和PriorityBlockingQueue使用较少,一般使用LinkedBlockingQueue和Synchronous。线程池的排队策略与BlockingQueue有关。 threadFactory:线程工厂,主要用来创建线程:默认值 DefaultThreadFactory; handler:表示当拒绝处理任务时的策略,就是上面提及的reject操作;有以下四种取值:   ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。(默认handle)   ThreadPoolExecutor.DiscardPolicy:也是丢弃任务,但是不抛出异常。   ThreadPoolExecutor.DiscardOldestPolicy:丢弃队列最前面的任务,然后重新尝试执行任务(重复此过程)   ThreadPoolExecutor.CallerRunsPolicy:由调用线程处理该任务 3:对线程池的基本使用及其部分源码的分析(注意:这里的源码分析是基于jdk1.6;) a:线程池的状态 volatile int runState; static final int RUNNING = 0; 运行状态 static final int SHUTDOWN = 1; 关闭状态;SHUTDOWN状态,此时线程池不能够接受新的任务,它会等待所有任务执行完毕 static final int STOP = 2;停止状态;此时线程池不能接受新的任务,并且会去尝试终止正在执行的任务 static final int TERMINATED = 3;终止状态;当线程池处于SHUTDOWN或STOP状态,并且所有工作线程已经销毁,任务缓存队列已经清空或执行结束后,线程池被设置为TERMINATED状态 b:参数再次说明。这是摘自网络的解释,我觉得他比喻的很好,所以这里直接就用它的解释   这里要重点解释一下corePoolSize、maximumPoolSize、largestPoolSize三个变量。   corePoolSize在很多地方被翻译成核心池大小,其实我的理解这个就是线程池的大小。举个简单的例子:   假如有一个工厂,工厂里面有10个工人,每个工人同时只能做一件任务。   因此只要当10个工人中有工人是空闲的,来了任务就分配给空闲的工人做;   当10个工人都有任务在做时,如果还来了任务,就把任务进行排队等待;   如果说新任务数目增长的速度远远大于工人做任务的速度,那么此时工厂主管可能会想补救措施,比如重新招4个临时工人进来;   然后就将任务也分配给这4个临时工人做;   如果说着14个工人做任务的速度还是不够,此时工厂主管可能就要考虑不再接收新的任务或者抛弃前面的一些任务了。   当这14个工人当中有人空闲时,而新任务增长的速度又比较缓慢,工厂主管可能就考虑辞掉4个临时工了,只保持原来的10个工人,毕竟请额外的工人是要花钱的。   这个例子中的corePoolSize就是10,而maximumPoolSize就是14(10+4)。   也就是说corePoolSize就是线程池大小,maximumPoolSize在我看来是线程池的一种补救措施,即任务量突然过大时的一种补救措施。   不过为了方便理解,在本文后面还是将corePoolSize翻译成核心池大小。   largestPoolSize只是一个用来起记录作用的变量,用来记录线程池中曾经有过的最大线程数目,跟线程池的容量没有任何关系。 c:添加线程池任务的入口就是execute(); 复制代码 public void execute(Runnable command) { if (command == null) throw new NullPointerException();//任务为空时抛出异常 //如果线程池线程大小小于核心线程,就新建一个线程加入任务并启动线程 //如果线程池线程大小大于核心线且且添加任务到线程失败,就把任务添加到阻塞队列 if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command)) {//新建线程并启动 if (runState == RUNNING && workQueue.offer(command)) {//添加任务到队列 if (runState != RUNNING || poolSize == 0) ensureQueuedTaskHandled(command);//添加到队列失败或已满,做拒接任务处理策略 } //若阻塞队列失败或已满;这里新建一个线程并启动做应急处理(这里就是用到了maximumPoolSize参数) else if (!addIfUnderMaximumPoolSize(command)) reject(command); // 若线程池的线程超过了maximumPoolSize;就做拒绝处理任务策略 } } 复制代码 -->>继续跟踪代码到addIfUnderCorePoolSize(Runnable firstTask):函数名称就可以看出来这个函数要执行的什么;如果线程池的线程小于核心线程数corePoolSize就新建线程加入任务并启动线程【在今后的开发中尽量把需要做的功能在函数名体现出来】 复制代码 private boolean addIfUnderCorePoolSize(Runnable firstTask) { Thread t = null; final ReentrantLock mainLock = this.mainLock;//获取当前线程池的锁 mainLock.lock();//加锁 try { /* 这里线程池线程大小还需要判断一次;前面的判断过程中并没有加锁,因此可能在execute方法判断的时候poolSize小于corePoolSize,而判断完之后,在其他线程中又向线程池提交了任务,就可能导致poolSize不小于corePoolSize了,所以需要在这个地方继续判断 */ if (poolSize < corePoolSize && runState == RUNNING) t = addThread(firstTask);//新建线程 } finally { mainLock.unlock(); } if (t == null) return false; t.start();//若创建线程超过,就启动线程池的线程 return true; } private Thread addThread(Runnable firstTask) { Worker w = new Worker(firstTask);//worker:ThreadPoolExecutor的内部类; Thread t = threadFactory.newThread(w);//使用线程工厂创建一个线程 if (t != null) { w.thread = t; workers.add(w);//保存线程池正在运行的线程 int nt = ++poolSize;//线程池的线程数加1 if (nt > largestPoolSize) largestPoolSize = nt; } return t; } 复制代码 -->>接下来定位worker类,看看线程池里的线程是如何执行的 上面的addIfUnderCorePoolSize(..)已经把线程启动了;现在就直接查看worker 的run()方法了 复制代码 public void run() { try { Runnable task = firstTask;//该线程的第一个任务,执行完后就从阻塞队列取任务执行 firstTask = null; while (task != null || (task = getTask()) != null) {//getTask()从队列去任务执行 runTask(task);//线程执行任务 task = null; } } finally { workerDone(this);//若任务全部执行完,就开始尝试去停止线程池;这部分代码就不再追踪下去,有兴趣的读者可以自己打开源码分析,不必害怕,学习大神们的编码方式,看源码能让你学习到很多 } } private void runTask(Runnable task) { final ReentrantLock runLock = this.runLock; runLock.lock(); try { //多次检查线程池有没有关闭 if (runState < STOP && Thread.interrupted() && runState >= STOP) thread.interrupt(); boolean ran = false; //这里就可以继承ThreadPoolExecutor,并覆盖beforeExecute(...)该方法,来做一些执行任务之前的统计工作或者用来保存正在执行的任务 beforeExecute(thread, task); try { task.run(); ran = true; //这里就可以继承ThreadPoolExecutor,并覆盖beforeExecute(...)该方法,来做一些执行任务完成之后的统计工作或者用来保存正在执行的任务 afterExecute(task, null); ++completedTasks;//统计总共执行的任务数 } catch (RuntimeException ex) { if (!ran) afterExecute(task, ex); throw ex; } } finally { runLock.unlock(); } } 复制代码 至此线程池基本的流程完了; 再说说我在项目中的使用: MyExtendThreadPoolExecutor 继承了 ThreadPoolExecutor,并覆盖了其中的一些方法 复制代码 public class MyExtendThreadPoolExecutor extends ThreadPoolExecutor{ public static Logger logger=LoggerFactory.getLogger(MyExtendThreadPoolExecutor.class); /** * 记录运行中任务 */ private LinkedBlockingQueue<Runnable> workBlockingQueue=new LinkedBlockingQueue<Runnable>(); public MyExtendThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) { super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue); } @Override protected void beforeExecute(Thread t, Runnable r) { super.beforeExecute(t, r); workBlockingQueue.add((GtdataBreakpointResumeDownloadThread)r);//保存在运行的任务 logger.info("Before the task execution"); } @Override protected void afterExecute(Runnable r, Throwable t) { super.afterExecute(r, t); workBlockingQueue.remove((GtdataBreakpointResumeDownloadThread)r);//移除关闭的任务 logger.info("After the task execution"); } /** * * Description: 正在运行的任务 * @return LinkedBlockingQueue<Runnable><br> * @author lishun */ public LinkedBlockingQueue<Runnable> getWorkBlockingQueue() { return workBlockingQueue; } } 复制代码 MyExtendThreadPoolExecutor pool = new MyExtendThreadPoolExecutor(3, 3,60L,TimeUnit.SECONDS,new LinkedBlockingQueue <Runnable>()); //创建线程池 复制代码 public void addToThreadPool(DownloadRecord downloadRecord){ BlockingQueue<Runnable> waitThreadQueue = pool.getQueue();//Returns the task queue LinkedBlockingQueue<Runnable> workThreadQueue =pool.getWorkBlockingQueue();//Returns the running work GtdataBreakpointResumeDownloadThread downloadThread = new GtdataBreakpointResumeDownloadThread(downloadRecord);//需要执行的任务线程 if (!waitThreadQueue.contains(downloadThread)&&!workThreadQueue.contains(downloadThread)) {//判断任务是否存在正在运行的线程或存在阻塞队列,不存在的就加入线程池(这里的比较要重写equals()) Timestamp recordtime = new Timestamp(System.currentTimeMillis()); logger.info("a_workThread:recordId="+downloadRecord.getId()+",name="+downloadRecord.getName()+" add to workThreadQueue"); downloadThread.setName("th_"+downloadRecord.getName()); pool.execute(downloadThread);//添加到线程池 }else{ logger.info("i_workThread:recordId="+downloadRecord.getId()+",name="+downloadRecord.getName()+" in waitThreadQueue or workThreadQueue"); } }

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值