黑马程序员技术交流社区
标题: 【厦门校区JavaEE就业3期-每日总结】异常、线程 [打印本页]
作者: 厦门校区 时间: 2018-8-17 19:26
标题: 【厦门校区JavaEE就业3期-每日总结】异常、线程
今天我们学习了异常和多线程，请根据自己的理解回答下面问题：
1.throw和throws的区别？
2.什么时候需要声明异常，什么时候不需要声明异常？
3.异常有几种处理方式？
4.什么是并发，什么是并行？
5.什么是进程，什么是线程？
6.run()方法和start()方法的区别？
作者: 张煜兴 时间: 2018-8-17 19:51
1.throw和throws的区别？
throw用于自定义异常的抛出，throws是用于异常代码的处理
2.什么时候需要声明异常，什么时候不需要声明异常？
当遇到代码编译异常时需要声明异常，当代码是运行异常时不需要声明
3.异常有几种处理方式？
有三种；一是不处理，二是Throws抛给方法调用者，若是在main方法中就抛给JVM处理，三是try...catch在当前方法处理抛出，也有用到JVM
4.什么是并发，什么是并行？
并发是进程的线程在时间轴上交替运行，并行是进程的线程在时间轴上共同运行
5.什么是进程，什么是线程？
进程是应用程序，进程是应用程序中的功能单元，至少有一个
6.run()方法和start()方法的区别？
使用run()，则是单线程执行代码，使用start()，则是多线程执行代码
作者: 黄艺纯 时间: 2018-8-17 20:04
1.throw和throws的区别？
throw关键字通常用在方法体中，并且抛出一个异常对象。程序在执行到throw语句时立即停止，它后面的语句都不执行。
throws关键字通常被应用在声明方法时，用来指定可能抛出的异常。多个异常可以使用逗号隔开。当在主函数中调用该方法时，如果发生异常，就会将异常对象抛给方法调用处。
2.什么时候需要声明异常，什么时候不需要声明异常？
编译时期的异常需要声明异常，运行时期的异常不需要声明异常。
3.异常有几种处理方式？
异常的处理方式有两种,分别是使用throws和try...catch...finally
throws用在方法的声明上后接异常类名,是把异常抛给调用者进行处理
try...catch...finally是捕获异常,自己处理,处理完毕后面的程序可以继续运行
a)try代码块中是可能出现异常的代码
b)catch代码块,是遇到异常,对异常进行处理的代码
c)finally代码块是无论是否发生异常,都必须执行的代码,用于释放资源.
4.什么是并发，什么是并行？
并行：指两个或多个事件在同一时刻发生（同时发生）。
并发：指两个或多个事件在同一个时间段内发生。
5.什么是进程，什么是线程？
进程指正在运行的程序。确切的来说，当一个程序进入内存运行，即变成一个进程，进程是处于运行过程中的程序，并且具有一定独立功能。
线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
6.run()方法和start()方法的区别？
run（）：线程的任务代码；
start（）：开启新线程，JVM调用run（）。
作者: 陈张辉 时间: 2018-8-17 20:08
1.throw和throws的区别？
** throw抛出异常。throws接收throw抛出的异常并抛给调用者
2.什么时候需要声明异常，什么时候不需要声明异常？
** 运行期不用 编译期必须
3.异常有几种处理方式？
** JVM默认处理 try catch处理
4.什么是并发，什么是并行？
** 一个人吃两个包子 两个人吃一个包子
5.什么是进程，什么是线程？
** 一个软件运行 进程的组成部分
6.run()方法和start()方法的区别？
**run（）是普通方法
**start() 包装run（）方法 使方法开辟一个新的线程
作者: 罗建辉 时间: 2018-8-17 20:18
1.throw和throws的区别？
throw用在方法内，用来抛出一个异常对象.
throws运用于方法声明之上,用于表示当前方法不处理异常,而是提醒该方法的调用者来处理异常(抛出异常)
2.什么时候需要声明异常，什么时候不需要声明异常？
异常分为编译时期异常与运行时期异常,其中编译时期 异常是需要声明与处理的,运行时期的异常可以处理也可以不处理,由JVM采取默认的处理方式
3.异常有几种处理方式？
throws:声明异常,向上抛出,由调用者来处理异常
自己处理,方法内部使用try...catch...finally
4.什么是并发，什么是并行？
并发： 在一个时间段内 执行多个程序（快速切换）
并行： 在一个时间点上 同时执行多个程序
5.什么是进程，什么是线程？
进程:每一个应用程序进入内存执行的时候 至少会有一个进程（描述一个程序从创建、运行、到销毁的过程）
线程:：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程
中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
6.run()方法和start()方法的区别？
run()方法是一个自定义类继承Thread后,需要重写run()方法,里面写的是需要同步的代码
start()方法是线程创建后,用来启动线程的方法.
作者: 张子建 时间: 2018-8-17 20:28
1.throw和throws的区别？
throw必须写在方法内部，用于抛出异常了。当抛出异常没有捕获处理就用throws进行声明，throws必须写在方法声明处，
2.什么时候需要声明异常，什么时候不需要声明异常？
编译时期异常需要声明异常，运行时期异常不需要声明异常
3.异常有几种处理方式？
两种，throws try...catch
4.什么是并发，什么是并行？
并发：在一个时间段内，执行多个程序（快速切换）
并行：在一个时间点上，同时执行多个程序
5.什么是进程，什么是线程？
进程：每一个应用程序进入内存执行的时候 至少会有一个进程（描述一个程序从创建、运行、到销毁的过程
线程：属于进程中的执行单元，一个进程中至少有一个线程（多个线程），每一个线程都有自己的线程任务
6.run()方法和start()方法的区别？
run方法里面写的是要执行的代码
start方法标志着开启了一个新线程
作者: Michcale 时间: 2018-8-17 21:02
--------------吴齐宾----------------------
1.throw和throws的区别？
1).throw用在方法体中，并且创建一个异常对象。
2)throws被应用在声明方法时，用来指定可能抛出的异常。
2.什么时候需要声明异常，什么时候不需要声明异常？
如果异常是编译异常时,需要声明异常,如果是运行异常就不需要声明异常
3.异常有几种处理方式？
2种,throw 和Try catch
4.什么是并发，什么是并行？
并行：同时运行多个进程。
并发：在一段时间内运行多个进程
5.什么是进程，什么是线程？
进程指正在运行的程序。
线程是进程中的一个执行单元，负责当前进程中程序的执行
6.run()方法和start()方法的区别？
run()方法.是指调用了run()中的代码块
start()方法是指开启了一个新的线程
作者: 丶黑白 时间: 2018-8-17 21:09
余志斌
1.throw和throws的区别？
throws是将异常对象抛给方法的调用者。
throw 一般跟new关键字，创建异常对象。参数为异常原因（可自行描述）。
2.什么时候需要声明异常，什么时候不需要声明异常？
不通过代码解决异常，而是将异常抛出或者是运行期异常的时候不需要声明异常。
3.异常有几种处理方式？
抛出或者捕获
4.什么是并发，什么是并行？
并发：快速切换、单个执行。
并行： 同时执行。
5.什么是进程，什么是线程？
进程是执行的程序，线程是进程的基本单元。
6.run()方法和start()方法的区别？
run（）方法重写线程的执行任务
start（）方法启动线程。
作者: 林靖 时间: 2018-8-17 21:10
1.throw和throws的区别？
throw关键字通常用在方法体中
try{
}catch{ throw new ??????????? }
finally{}
，并且抛出一个异常对象。程序在执行到throw语句时立即停止，它后面的语句都不执行,但在finally修饰的代码块中的代码一定会执行。
throws关键字通常被应用在声明方法时，用来指定可能抛出的异常。多个异常可以使用逗号隔开。
2.什么时候需要声明异常，什么时候不需要声明异常？
如果异常是编译异常时,需要声明异常,如果是运行异常就不需要声明异常
3.异常有几种处理方式？
throws抛出
try...catch...finally捕获
4.什么是并发，什么是并行？
并行：同个时间点运行多个进程。
并发：在一段时间段运行多个进程
5.什么是进程，什么是线程？
应用程序在内存中进行的创建、运行、销毁 的过程叫做进程
进程的执行单元叫做线程负责为进程向内存开辟路径
6.run()方法和start()方法的区别？
run()方法.是指调用了run()中的代码块
start()方法是启动线程的方法
作者: 郭生发 时间: 2018-8-17 21:14
1.throw和throws的区别？
throw在方法内部后接异常对象，产生异常后抛出异常对象
throws在方法声明上，在参数列表后，后接异常名，声明可能产生的异常
2.什么时候需要声明异常，什么时候不需要声明异常？
当使用try...catch处理异常时不需要声明异常。当抛出的异常是运行时期异常时不需要声明异常。
3.异常有几种处理方式？
两种处理方法，一种是使用try...catch处理异常
一种是用throws抛出异常给调用者
4.什么是并发，什么是并行？
多个事件在同一时间段内发生叫并发（交替非同时）
多个事件在同一时刻发生叫并行。（同时）
5.什么是进程，什么是线程？
启动程序进入内存运行，进入内存的
程序叫进程，一个程序至少有一个进程，可以有多个
线程是进程的执行单元。一个进程至少有一个线程，可以有多个。
6.run()方法和start()方法的区别？
run()方法内为需要开启新线程运行的代码。
Thread的对象调用start()，通过JVM再调用run()方法开启线程运行程序。
作者: liebstch 时间: 2018-8-17 21:14
陈建秋
1.throw和throws的区别？（1） throw关键字通常用在方法体中，并且抛出一个异常对象。程序在执行到throw语句时立即停止，它后面的语句都不执行。
（2）throws关键字通常被应用在声明方法时，用来指定可能抛出的异常。多个异常可以使用逗号隔开。当在主函数中调用该方法时，如果发生异常，就会将异常对象抛给方法调用处。
2.什么时候需要声明异常，什么时候不需要声明异常？
当异常是运行时异常，或者使用try..cath()语句处理异常时，不需要再声明异常。
3.异常有几种处理方式？
异常的处理方式有两种,分别是使用throws和try...catch...finally
4.什么是并发，什么是并行？
并行：指两个或多个事件在同一时刻发生（同时发生）。
并发：指两个或多个事件在同一个时间段内发生。
5.什么是进程，什么是线程？
进程指正在运行的程序。确切的来说，当一个程序进入内存运行，即变成一个进程，进程是处于运行过程中的程序，并且具有一定独立功能。
线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
6.run()方法和start()方法的区别？
直接调用run方法执行的时候还是在主线程中执行的并没有再开启线程。
调用start()方法会开启一个线程执行run()方法中的代码
作者: 李志超 时间: 2018-8-17 21:15
今天我们学习了异常和多线程，请根据自己的理解回答下面问题：
1.throw和throws的区别？
throw：抛出异常，用来创建异常对象，并抛出给调用者。
throws：声明异常，当方法内没有对这个异常进行处理时，需要将这个异常对调用者进行声明，当调用者也没有对异常进行处理时，声明给JVM进行默认处理。
2.什么时候需要声明异常，什么时候不需要声明异常？
当方法内部没有对异常进行处理时就需要声明异常。如果有进行try..catch处理则不需要。
3.异常有几种处理方式？
throw&try..catch
4.什么是并发，什么是并行？
并发：两个及以上事件在同一时间段运行，交替执行。
并行：两个及以上时间在同一时刻进行，同时执行。
5.什么是进程，什么是线程？
进程：进入内存的程序，一个应用程序运行至少有一个进程。
线程：开辟应用程序到CPU的路径，每个应用程序至少有一个线程，可包含多个线程。
6.run()方法和start()方法的区别？
需要重写run方法，定义我们想要的代码内容，但不需要我们调用，属于JVM进行调用。
start方法，是我们使用对象进行调用，调用后，将线程运行信息传递给JVM处理。
作者: 谢君昇 时间: 2018-8-17 21:15
1.throw和throws的区别？throw写在方法中，抛出一个异常对象，执行到此是程序终止；
throws写在方法声明处，把异常抛给调用者；
2.什么时候需要声明异常，什么时候不需要声明异常？
编译时期的异常需要声明，运行时期的异常不需要声明；
3.异常有几种处理方式？
thows和try..catch两种；
4.什么是并发，什么是并行？
并发：在同一个时间段内执行多个程序（快速切换）；
并行：在同一个时间点内执行多个程序；
5.什么是进程，什么是线程？
进程：一个程序在进入内存产生至少一个进程，进程就是程序创建，执行，销毁的过程；
线程：是进程的执行单元，一个进程至少有一个线程，每一个线程都有自己的线程任务；
6.run()方法和start()方法的区别？
run（）中写的是要执行的代码块；
start（）标志着一个线程的开启，并且由JVM调用run（）；
作者: sulaymanfan 时间: 2018-8-17 21:18
yefan
1.throw和throws的区别？ throw 用在方法体内,跟的是异常对象名,只能抛出一个异常对象,
throws用在方法声明后面,跟的是异常类名,可以跟多个异常类名,由方法的调用者处理
2.什么时候需要声明异常，什么时候不需要声明异常？
编译时异常时需要声明异常
运行时异常时不需要声明
3.异常有几种处理方式？
异常由两种:
1, 一直往调用者抛,直到jvm执行
2, 用try....cacht捕获异常
4.什么是并发，什么是并行？
并发是值;在一段时间内执行多个任务
并行是值:在一个时间点同事执行多个任务
5.什么是进程，什么是线程？
进程是值:程序进入内存,程序创建,执行,销毁的过程.
6.run()方法和start()方法的区别？
run()是调用执行 ,start()方法是开启线程.
作者: 陈锦祥 时间: 2018-8-17 21:18
1.throw和throws的区别？ throw
作用:可以使用throw关键字在指定的方法中抛出指定的异常 使用格式:throw new xxxException("异常产生的原因");
注意:1.throw关键字必须写在方法的内部
2.throw关键字后边new的对象必须是Exception或者Exception的子类对象
3.throw关键字抛出指定的异常对象,我们就必须处理这个异常对象
throw关键字后边创建的是RuntimeException或者是 RuntimeException的子类对象,我们可以不处理,默认交给JVM处理(打印异常对象,中断程序)
throw关键字后边创建的是编译异常(写代码的时候报错),我们就必须处理这个异常,要么throws,要么try...catch
throws
异常处理的一种方式,交给别人处理
作用:当方法内部抛出异常对象的时候,那么我们就必须处理这个异常对象
可以使用throws关键字处理异常对象,会把异常对象声明抛出给方法的调用者处理(自己不处理,给别人处理),最终交给JVM处理-->中断处理
使用格式:在方法声明时使用
修饰符 返回值类型 方法名(参数列表) throws AAAExcepiton,BBBExcepiton...{
throw new AAAExcepiton("产生原因");throw new BBBExcepiton("产生原因"); ... }
2.什么时候需要声明异常，什么时候不需要声明异常？
方法内部有出现编译期异常 需要声明异常 即throws xxxxxExcepiton
遇到运行期异常可以不用声明异常 JVM会按照默认的方式处理该异常；
3.异常有几种处理方式？
第一种方式：throws 声明异常，自己本身不处理 丢给调用处 处理；
第二种方式：try.....catch..... 捕获异常 处理异常 自己处理；
4.什么是并发，什么是并行？
并发：交替执行
并行：同时执行
5.什么是进程，什么是线程？
进程：是指一个内存中运行的引用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程，进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序及时一个进程从创建运行到消亡的过程， 即进入到内存中的程序
线程：线程是进程的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程
6.run()方法和start()方法的区别？
run（）: run方法 如果是在thread的子实现类中 则代表 线程所要执行的任务代码 如果不是在thread的子实现类中 或者是单独调用run方法 则就是一般的方法调用而已；
start（）： 为开启线程的方法 会去调用到 thread子实现类中的run 方法的内容。
作者: 李伟javaee03 时间: 2018-8-17 21:19
1. throw和throws的区别？
Throw用在方法内，用来抛出一个异常，程序运行至throw语句变会停止
Throws写在方法声明处，将异常对象抛给调用者处理，最终交给JVM处理
2.什么时候需要声明异常，什么时候不需要声明异常？
没有用try…catch处理的编译期异常需要声明异常，运行期异常不需要声明异常
3.异常有几种处理方式？
Throws，声明抛出异常
Try…catch捕获异常，逻辑处理
4.什么是并发，什么是并行？
并发就是多个事件在同一个时间段发生，每个时刻只能处理一个时事件
并行就是多个事件在同一时刻发生
5.什么是进程，什么是线程？
进程是指正在运行的程序
线程是进程中的执行单元，一个进程中至少有一个线程，也可以有多个线程。
6.run()方法和start()方法的区别？
Run()方法是新线程所需要执行的内容
Start()方法是开启新线程
作者: ZNBran 时间: 2018-8-17 21:24
1throw写在方法内部抛出异常对象，throws写在方法的声明处声明异常对象。
2编译时期异常需要声明异常并且把异常对象向调用者抛出，运行时期异常不需要进行声明有JVM进行解决。
3异常有2种解决方式：第一种使用try...catch进行异常捕获，第二种用throw向上抛出异常。
4并发就是同一时间段多个进程交替执行（每次只执行一个进程）。
并行就是同一时间段多个进程同时执行。
5进程就是程序进入内存执行的一系列过程。
线程就是进程的执行单元，进程想要执行至少需要使用一个线程
6run()方法和start()方法都是Tread类中的方法，run()方法相当于普通方法需要被Tread子类方法重写
而start()方法被Tresd子类方法对象调用时JVM会开辟一个新的线程，然后调用执行被重写的run()方法，总的来说start()方法用来开辟新的线程，run()方法是新线程中所执行的方法。
===================================================== 周楠
作者: 赵烈刚 时间: 2018-8-17 21:24
1．throw和throws的区别？
throw和throws的区别在于：throw用在方法内，用来抛出一个异常对象，将这个异常对象传递到调用者处，并结束当前方法的执行。throws运用于方法声明之上,用于表示当前方法不处理异常,而是提醒该方法的调用者来处理异常(抛出异常)
2.什么时候需要声明异常，什么时候不需要声明异常？
在编译过程中报错要声明异常抛出异常给调用者处理；在运行时期报错不需要生命异常，，交给JVM处理不会影响程序的运行。
3.异常有几种处理方式？
两种；throws和try...catch
4.什么是并发，什么是并行？
并发：指两个或多个事件在同一时间段发生；
并行：指两个或多个事件在同一时间点（同时）发生。
5.什么是进程，什么是线程？
进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程；
线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
6.run()方法和start()方法的区别？
run()执行是线程执行体；start()标志着开启了一个新线程。
作者: 仰望｀星空 时间: 2018-8-17 21:26
郭林源
1.throw和throws的区别？--->throw写在方法的内部，throws写在方法的参数列表后；throw是抛出异常对象，throws是声明异常，让调用者处理
2.什么时候需要声明异常，什么时候不需要声明异常？--->编译时期异常未使用异常处理逻辑代码时，须声明异常，运行时期异常不需要声明，因为效果是一样的
3.异常有几种处理方式？--->有2种，一种是throw抛出异常，由调用者处理，最终由JDK使用默认方法处理，一种是异常处理逻辑try。。。catch，捕捉异常，可以让开发者更灵活的处理异常
4.什么是并发，什么是并行？--->并发：一个时间段内，运行多个任务，cpu在多任务间快速切换
并行：一个时间点，同时运行多个任务
5.什么是进程，什么是线程？--->一个程序进入内存中执行时，是一个程序的创建-运行-销毁的过程，一个程序运行至少有多个进程；线程就是进程的执行单元，应用程序到cpu的执行路径，一个进程至少有一个线程
6.run()方法和start()方法的区别？--->run方法是Thread类的方法，我们需要重写run方法，编辑线程的任务代码。star方法标志着开启新线程，调用star方法后，JVM会调用run方法，从而开启线程
作者: 铜墙铁壁花无缺 时间: 2018-8-17 21:26
=================余金龙=============
1.throw和throws的区别？
1. throw关键字通常用在方法体中，并且抛出一个异常对象。程序在执行到throw语句时立即停止，它后面的语句都不执行。
2. throws关键字通常被应用在声明方法时，用来指定可能抛出的异常。多个异常可以使用逗号隔开。当在主函数中调用该方法时，如果发生异常，就会将异常对象抛给方法调用处。
2.什么时候需要声明异常，什么时候不需要声明异常？
答：编译时期产生的异常必须申明该异常，并且处理它
运行时期产生的异常可以不用申明系统默认交给jvm处理
3.异常有几种处理方式？
答：
1. 异常的处理方式有两种,分别是使用throws和try...catch...finally2. throws用在方法的声明上后接异常类名,是把异常抛给调用者进行处理
3. try...catch...finally是捕获异常,自己处理,处理完毕后面的程序可以继续运行
a) try代码块中是可能出现异常的代码
b) catch代码块,是遇到异常,对异常进行处理的代码
c) finally代码块是无论是否发生异常,都必须执行的代码,用于释放资源.
4.什么是并发，什么是并行？
并行：指两个或多个事件在同一时刻发生（同时发生）。
并发：指两个或多个事件在同一个时间段内发生。
5.什么是进程，什么是线程？
进程指正在运行的程序。确切的来说，当一个程序进入内存运行，即变成一个进程，进程是处于运行过程中的程序，并且具有一定独立功能。
线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
一个程序运行后至少有一个进程，一个进程中可以包含多个线程,但一个进程中至少包含一个线程。比如使用迅雷软件下载网络文件时，同时下载多个文件，就使用到了多线程下载。
6.run()方法和start()方法的区别？
答:
1 run方法是线程任务的代码 创建一个类继承Thread 要重写该方法
2 start（）方法在测试类中创建对象来调用该方法，开启多线程
作者: yangshixian 时间: 2018-8-17 21:27
本帖最后由 yangshixian 于 2018-8-17 21:29 编辑
1.throw和throws的区别？throws是声明抛出 在方法名后部声明异常
throw是抛出异常 写在方法的内部
2.什么时候需要声明异常，什么时候不需要声明异常？
当要使用throw关键字抛出异常时需要声明异常，即要将异常交给虚拟机处理的情况需要声明异常使用try...catch处理异常时不需要声明异常
3.异常有几种处理方式？
两种
throw抛出异常交给虚拟机处理
try...catch捕获异常
4.什么是并发，什么是并行？
并发是多个事件在同一时间段交替运行
并行是多个事件在同一时刻同时发生
5.什么是进程，什么是线程？
进程：一个内存中运行的应用程序，每个程序都有一个独立的内存空间，是系统运行程序的基本单位
线程：一个进程中可以有多个执行单元同时进行，这些执行单元被称为线程
6.run()方法和start()方法的区别？
直接通过对象调用run()仅是调用方法并没有开启新线程；调用start()方法时，开启一条新线程并调用run方法
杨式贤
作者: 黄伟佳 时间: 2018-8-17 21:28
1.throw和throws的区别？
throw关键字通常用在方法体中
throws关键字通常应用在声明方法
2.什么时候需要声明异常，什么时候不需要声明异常？
编译异常时,需要声明异常
运行异常不需要声明异常
使用try..cath()语句不需要声明异常
3.异常有几种处理方式？
两种，cry catch以及throws
4.什么是并发，什么是并行？
并发：一个人吃两馒头
并行：两个人吃两馒头
5.什么是进程，什么是线程？
一个程序运行进内存就叫进程
线程是进程的一个单元一个进程里最少有一条线程
6.run()方法和start()方法的区别？
run（）方法用来覆盖重写需要并行线程的内容，
sta（）用来实现并行线程
作者: 郑颖锋 时间: 2018-8-17 21:28
1.throw和throws的区别？
throw关键字用在方法体中，抛出一个异常， 程序在执行到throw语句时立即停止，它后面的语句都不执行。
throws关键字通常被应用在声明方法时，用来指定可能抛出的异常。多个异常可以使用逗号隔开。
当在主函数中调用该方法时，如果发生异常，就会将异常对象抛给方法调用处。
2.什么时候需要声明异常，什么时候不需要声明异常？
当异常时运行异常或者已用try…catch处理的异常就不用再声明异常。
3.异常有几种处理方式？
两种：throws直接抛出异常，交给JVM处理
自己处理，利用try…catch语句处理异常
4.什么是并发，什么是并行？
并发是指两个或者多个事件在同一个时间段内发生。
并行是指两个或者多个事件在同一个时刻发生。
5.什么是进程，什么是线程？
进程指正在运行的程序。确切的来说，当一个程序进入内存运行，即变成一个进程，进程是处于运行过程中的程序，并且具有一定独立功能。一个应用程序中可有一个或多个进程。
线程是进程中的一个执行单元，负责当前进程的执行。一个进程中可有一个或多个线程。
6.run()方法和start()方法的区别？
run()方法是父类Thread的方法，创建一个自定义线程时需要重写。run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体。
start()是线程对象用来启用线程的一个方法。 当调用start方法之后，JVM帮我们调用run方法，从而开启新线程。
作者: 小鱼七 时间: 2018-8-17 21:32
1.throw和throws的区别？
throw用来抛出异常，throws用来声明异常
2.什么时候需要声明异常，什么时候不需要声明异常？
编译期需要声明异常，运行期不需要声明异常
3.异常有几种处理方式？
1、抛出异常throw和throws
2、捕获异常try...catch（）...finally
4.什么是并发，什么是并行？
并发是时间段内程序同时运行（在程序意见快速切换）
并行是在时间点上两个货多个程序同时运行
5.什么是进程，什么是线程？
进程是程序运行的最小单元，至少包含一个进程
线程是进程的最小单元，进程中至少包含一个线程
6.run()方法和start()方法的区别？
run方法在重写时使用，方法体内即需要线程完成的任务代码，线程启动后虚拟机自动调用；
start方法为启动线程的方法，需要线程对象来调用。 |
|
作者: 沈智桂 时间: 2018-8-17 21:35
1.throw和throws的区别？
throw是创建一个异常对象，描述发生异常的问题，有异常必须马上处理，抛出异常或者抓捕异常，异常后面的代码不执行。throws是抛出异常，让这个方法的调用者来处理这个异常
2.什么时候需要声明异常，什么时候不需要声明异常？
如果是编译时期的异常，你要么用try...catch，要么就是抛出异常，声明异常，在运行时期的错误，可以不声明异常，默认声明了异常
3.异常有几种处理方式？
两种，一种是声明异常throws，一种是在方法内try...catch
4.什么是并发，什么是并行？
并发是在一个时间段执行多个进程（交替执行）
并行是在同一个时间点同时执行多个进程（同时发生）
5.什么是进程，什么是线程？
进程是一个应用程序进入内存中，进程是程序从创建到运行到销毁的过程
线程是进程的一个基本单元。每一个线程都执行一种任务。每一个进程至少有一个线程
6.run()方法和start()方法的区别？
start（）方法是子类对象调用他，就相当于开启一个新的线程，
run（）方法是子类需要重写的方法
作者: 刘建宝 时间: 2018-8-17 21:35
1.throw和throws的区别？
使用位置不同：throw 使用在方法内 ，throws 使用在方法参数后面（方法声明处）
作用不同：throw 是抛出异常对象给调用者；
throws 声明throw抛出的异常，表示不处理，给调用者处理，最终结果是交给JVM处理
2.什么时候需要声明异常，什么时候不需要声明异常？
当异常不需要处理的时候 使用声明异常，交于调用者处理
当父类没有声明异常，子类也不能声明异常
3.异常有几种处理方式？
两种， 1.throws 声明异常，交于调用者方法者处理
2.try...catch 传入有可能发生异常的代码，进行判断，若存在异常，则使用catch处理异常
4.什么是并发，什么是并行？
并发 ： 在同一个时间段中，执行多个程序(快速切换)
并行 ： 在同一个时间点上，同时执行多个程序；
5.什么是进程，什么是线程？
进程：每一个应用程序进入内存执行的时候 至少会有一个进程（描述一个程序从创建、运行、到销毁的过程）
线程：属于进程中的执行单元，一个进程中至少有一个线程（多个线程），每一个线程都有自己的线程任务
6.run()方法和start()方法的区别？
run（）是Thread类的一个方法 ，而start（）是启动线程的一个方法；
对象调用run方法时，只是单线程的执行该方法内容；
对象调用start方法时，是启动线程后，JVM 会自动调用run方法；
作者: 舟sir 时间: 2018-8-17 21:41
今天我们学习了异常和多线程，请根据自己的理解回答下面问题：
1.throw和throws的区别？
throw关键字通常用在方法体中，并且抛出一个异常对象。程序在执行到throw语句时立即停止，它后面的语句都不执行。 throws关键字通常被应用在声明方法时，用来指定可能抛出的异常。多个异常可以使用逗号隔开。当在主函数中调用该方法时，如果发生异常，就会将异常对象抛给方法调用处。 2.什么时候需要声明异常，什么时候不需要声明异常？
编译异常必须处理必须声明或者try...catch 处理
运行异常可以不用声明
3.异常有几种处理方式？
两种throws try...catch
4.什么是并发，什么是并行？
并发：同个时间段交替执行
并行：多个事件，同时执行
5.什么是进程，什么是线程？
进程：进入内存的程序叫进程
线程：执行内存的单元，一个进程至少一个线程，一般多个
6.run()方法和start()方法的区别？
run（）方法是线程支持任务的代码块，不能自己调用启动线程
start（）方法使该线程开始执行；jvm 调用该线程的 run 方法。
周家乾 |
|
作者: weimengchao 时间: 2018-8-17 21:45
1.throw和throws的区别？
throw 抛出一个对象
throws将异常抛出给调用者
2.什么时候需要声明异常，什么时候不需要声明异常？
方法内的编译时异常需要在方法定义处申明异常
运行时异常不用声明，虚拟机自动创建
3.异常有几种处理方式？
throws
try。。catch
4.什么是并发，什么是并行？
一个时间段做多件事情
一个时间点做多点事情
5.什么是进程，什么是线程？
程序的生命周期过程
程序的最小执行单位
6.run()方法和start()方法的区别？
run方法是线程执行的内容
start方法是线程执行的方法
作者: 林嘉志 时间: 2018-8-17 21:46
1.throw和throws的区别？
位置不一样
throw写在方法体里，用来抛出异常，且一旦执行，后面的代码不会再执行
throws写在参数列表后，用来声明异常，指定可能抛出的异常，多个异常可以使用逗号隔开。当在主函数中调用该方法时，如果发生异常，就会将异常对象抛给方法调用处。
2.什么时候需要声明异常，什么时候不需要声明异常？
当代码在编译时期可能会出现异常时，需要声明异常。当代码没有异常时，或者代码有异常，但会处理(try 。。 。 catch)的时候不需要声明异常
3.异常有几种处理方式？
两种 抛出异常和处理异常
4.什么是并发，什么是并行？
并行：指两个或多个事件在同一时刻发生（同时发生）。
并发：指两个或多个事件在同一个时间段内发生。
5.什么是进程，什么是线程？
执行的程序就是进程
线程时进程的执行单元，负责当前进程中程序的执行
程序执行后，至少有一个进程，一个进程有包含多个线程，但是至少有一个线程
6.run()方法和start()方法的区别？
run方法是需要重写的方法，
但是开启进程需要调用start方法，而不是run方法
可能每次执行的顺序都不一样，看电脑配置
作者: 苏华琛 时间: 2018-8-17 21:47
1.throw和throws的区别？
throw是抛出异常
throws是声明异常，
2.什么时候需要声明异常，什么时候不需要声明异常？
throw：当调用方法使用参数时，若参数不合法就应当使用抛出异常
throws：运用于方法声明之上,用于表示当前方法不处理异常,而是提醒该方法的调用者来处理异常
3.异常有几种处理方式？
I. 多个异常分别处理。
II. 多个异常一次捕获，多次处理。
III. 多个异常一次捕获一次处理。
4.什么是并发，什么是并行？
并发就类似与一个人做事一件接一件
并行就相当于一群人一起做事
5.什么是进程，什么是线程？
进程是一个应用程序进入内存中，进程是程序从创建到运行到销毁的过程
线程是进程的一个基本单元。每一个线程都执行一种任务。每一个进程至少有一个线程
6.run()方法和start()方法的区别？
调用start（）方法时自动调用run（）方法
作者: spik 时间: 2018-8-17 21:47
1.throw和throws的区别？
throw用于方法体内抛出异常对象信息，throws用于在方法名中声明异常
2.什么时候需要声明异常，什么时候不需要声明异常？
编译异常时,需要声明异常，运行异常不需要声明异常
3.异常有几种处理方式？
两种方式：1、用throws抛出由调用者处理。
2、用 try{…}catch(){…}做捕获处理。
4.什么是并发，什么是并行？
并行是在同一时间点发生的事件；并发是在同一时间段内发生的事件。
5.什么是进程，什么是线程？
进程是程序执行时进入内存创建、运行、到销毁的过程
线程是指进程中的执行单元，每个进程中至少有一个线程，每一个线程都有自己的线程任务。
6.run()方法和start()方法的区别？
start()使该线程开始执行， 虚拟机会调用该线程的 run 方法。
run()是线程的执行体
lijionghua
作者: 迪亚波罗 时间: 2018-8-17 21:47
1.throw是创建一个异常对象,需要立刻处理或者抛出异常.throws是抛出异常对象让这个方法调用者来处理异常.
2.在编译时期需要声明异常,在运行时期可以不声明异常,因为JVM声明了异常
3.声明异常throw和方法内部try...catch
4.并发是同一个时间段内多个程序执行.并行是同一个时间点内多个程序执行
5.进程就是程序在内存开辟了一个空间,进程是程序执行一次的过程,程序在空间创建,运行,销毁的过程
线程是进程的执行单元,一个进程至少一个线程 .含有多个线程的叫做多线程
5.run()在重写时使用，方法体内即需要线程完成的任务代码，线程启动后虚拟机自动调用
start()为启动线程的方法，需要线程对象来调用。
孙享
作者: 罗荣贵 时间: 2018-8-17 21:47
1.throw 用在方法内 ，异常类对象前, throws 用在方法列表后，紧跟Exception 或者 RunTimeException 或他们的子类，抛出异常给调用者
2.如果编译期期异常需要声明，运行期的异常可以不用声明，用捕获处理异常也不需要声明异常
3.能够使用try...catch关键字处理异常
try{
可能发生异常的代码
}catch(异常类型名称 e){
}catch(异常类型名称 e){
}...
tips:子类的异常在上边
能够使用throws关键字处理异常
throws 声明抛出
4.并行是在同一个时间点同时执行，并发是一段时间交替执行
5.进程是应用程序进入内存的创建，运行，到销毁的整个过程，一个程序至少有一个进程，线程属于进程，是进程执行过程的单元
6.run()方法是被虚拟机调用，重写这个方法，方法内部是线程功能代码 ，start()方法被线程类对象调用，用来开启新的线程
作者: 赖良峰 时间: 2018-8-17 21:48
1.throw和throws的区别？ throw是用来创建异常对象的
throws是重来处理异常对象的(甩锅专业户)
2.什么时候需要声明异常，什么时候不需要声明异常？
异常是运行期异常可以默认不写声明异常
3.异常有几种处理方式？
两种 throws
try---catch
4.什么是并发，什么是并行？
某个时间点多个任务同时进行叫并行
某个时间段多个任务交替进行叫并发
5.什么是进程，什么是线程？
进程就是内存中执行的程序
线程就是程序要使用CPU时通向CPU的路径
6.run()方法和start()方法的区别？
Start方法是JVM用来开启线程的
run方法是Thread里的一个方法,通过重写这个方法我们可以给线程设定执行任务;
作者: 黄晨伟 时间: 2018-8-17 21:49
1.throw关键字通常用在方法体中，并且抛出一个异常对象。程序在执行到throw语句时立即停止，它后面的语句都不执行。
throws关键字通常被应用在声明方法时，用来指定可能抛出的异常。多个异常可以使用逗号隔开。当在主函数中调用该方法时，如果发生异常，就会将异常对象抛给方法调用处。
2.编译异常需要声明，运行异常不需要
3.异常的处理方式有两种,分别是使用throws和try...catch...finally
4.并发：指两个或多个事件在同一个时间段内发生
并行：指两个或多个事件在同一刻发生（同时发生）
5.进程：一个程序进入内存运行，即变成一个进程，进程是处于运行过程中的程序，并且具有一定独立功能
线程：进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序
6.run()重写新的方法
start()开启新的线程执行run()
作者: 练志成 时间: 2018-8-17 21:49
今天我们学习了异常和多线程，请根据自己的理解回答下面问题：
1.throw和throws的区别？
throw在方法中
throws在方法声明处
2.什么时候需要声明异常，什么时候不需要声明异常？
编译期异常抛出需要声明，
运行期异常或者自己处理都不需要声明
3.异常有几种处理方式？
4.什么是并发，什么是并行？
并发：指两个或多个事件在同一个时间段内发生
并行：是指同时发生
5.什么是进程，什么是线程？
进程是指在运行的应用程序
线程是指进程里的运行道路
6.run()方法和start()方法的区别？
run方法重写，start方法是调用
作者: 林胜强 时间: 2018-8-17 21:50
1.throw和throws的区别？
1.throw关键字通常用在方法体中，并且抛出一个异常对象。程序在执行到throw语句时立即停止，它后面的语句都不执行。
throws关键字通常被应用在声明方法时，用来指定可能抛出的异常。
2.什么时候需要声明异常，什么时候不需要声明异常？
编译异常需要声明或者try...catch...finally
3.异常有几种处理方式？
两种 throws try...catch...finally
4.什么是并发，什么是并行？
同一时间段发生的叫并广发 ，同一时刻发生的叫并行
5.什么是进程，什么是线程？
进程是一个应用程序进入内存中，进程是程序从创建到运行到销毁的过程
线程是进程的一个基本单元。每一个线程都执行一种任务。每一个进程至少有一个线程
6.run()方法和start()方法的区别？
run方法是Thread类中的一个方法
一个类继承Thread类，去覆盖重写run方法。在创建对象后，运行对象名.run（）只是调用该方法
对象名.start()是开启一个新线程并调用run方法
作者: 张剑猛 时间: 2018-8-17 21:50
1.throw和throws的区别？
throw通常用在方法体内，表示抛出异常对象，jvm中断程序运行；throws通常用在方法的声明区，表示如果发生异常将抛出异常对象给调用方法处
2.什么时候需要声明异常，什么时候不需要声明异常？
发生编译期异常时需要声明异常或者用try...catch...finally...处理异常；如果是运行期异常可以不声明让JVM默认处理。
3.异常有几种处理方式？
Throws和try...catch...finally...两种处理方式
4.什么是并发，什么是并行？
并发：两个或两个以上事件在同一时间段内发生。
并行：两个或两个以上事件在同一时间点发生。
5.什么是进程，什么是线程？
进程：程序进入内存运行，
线程：进程中的一个执行单位，负责当前进程中程序的执行，一个进程可以有多个线程
6.run()方法和start()方法的区别？
run()方法是Thread类的一个方法，创建Thread需要重写该方法
start（）方法 使线程开始执行；Java 虚拟机调用该线程的 run 方法
作者: 冰是睡着的水 时间: 2018-8-17 21:55
1.throw和throws的区别？
答：throw用来创造异常对象的关键字。throws用来
抛出异常。
2.什么时候需要声明异常，什么时候不需要声明异常？
答：当异常要自己处理时就不用声明异常，当异常要
抛给别人时就需要声明异常。
3.异常有几种处理方式？
答：分为编译期异常和运行期异常。编译期异常可以有
两种处理方式，一种是自己处理，利用try...catch...finally,
另外一种是交给他人处理，使用throw关键字。运行期异常
可以不处理，也可以处理，处理时也有两种方法，同上。
4.什么是并发，什么是并行？
答：并发是在同一时间段发生。并行是在同一时刻发生。
5.什么是进程，什么是线程？
答：每一个程序进入内存执行的时候至少会有一个进程，
其描述了一个程序从创建、运行、销毁的过程。线程是
进程中的执行单元，一个进程中至少有一个线程，每一个
线程都有自己的任务。
6.run()方法和start()方法的区别？
答：run()方法就是实现线程想完成的功能。start()方法一
旦被调用就标志着开启了一个新线程，JVM会帮我们调用
run()方法。
（黄嘉欣）
作者: 冰是睡着的水 时间: 2018-8-17 21:56
1.throw和throws的区别？
答：throw用来创造异常对象的关键字。throws用来
抛出异常。
2.什么时候需要声明异常，什么时候不需要声明异常？
答：当异常要自己处理时就不用声明异常，当异常要
抛给别人时就需要声明异常。
3.异常有几种处理方式？
答：分为编译期异常和运行期异常。编译期异常可以有
两种处理方式，一种是自己处理，利用try...catch...finally,
另外一种是交给他人处理，使用throw关键字。运行期异常
可以不处理，也可以处理，处理时也有两种方法，同上。
4.什么是并发，什么是并行？
答：并发是在同一时间段发生。并行是在同一时刻发生。
5.什么是进程，什么是线程？
答：每一个程序进入内存执行的时候至少会有一个进程，
其描述了一个程序从创建、运行、销毁的过程。线程是
进程中的执行单元，一个进程中至少有一个线程，每一个
线程都有自己的任务。
6.run()方法和start()方法的区别？
答：run()方法就是实现线程想完成的功能。start()方法一
旦被调用就标志着开启了一个新线程，JVM会帮我们调用
run()方法。
（黄嘉欣）
作者: 陈捷 时间: 2018-8-17 21:57
1.throw和throws的区别？
throw关键字通常用在方法体中，并且抛出一个异常对象。程序在执行到throw语句时立即停止，它后面除了finally语句外的其他语句都不执行。
throws关键字通常被应用在声明方法时，用来指定可能抛出的异常。多个异常可以使用逗号隔开。当在主函数中调用该方法时，如果发生异常，就会将异常对象抛给方法调用处。
2.什么时候需要声明异常，什么时候不需要声明异常？
当异常是运行时异常，或者使用try..cath()语句处理异常时，不需要再声明异常。
3.异常有几种处理方式？
异常的处理方式有两种,分别为：
throws和try...catch...finally
4.什么是并发，什么是并行？
并行：指两个或多个事件在同一时刻发生（同时发生）。
并发：指两个或多个事件在同一个时间段内发生。
5.什么是进程，什么是线程？
进程指正在运行的程序。确切的来说，当一个程序进入内存运行，即变成一个进程，进程是处于运行过程中的程序，并且具有一定独立功能。
线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程。
6.run()方法和start()方法的区别？
直接调用run方法执行的时候还是在主线程中执行的并没有再开启线程。
调用start()方法会开启一个线程执行run()方法中的代码
作者: 吴鑫佳 时间: 2018-8-17 21:57
1.throw和throws的区别？
throw是关键字，它用来抛出一个指定的异常对象，抛出对象给使用者需要声明，这是由就是用throw是将异常对象调用去使用者。throws进行的就是声明处理。
2.什么时候需要声明异常，什么时候不需要声明异常？
当需要把异常返回给其他使用者是就需要，当异常自己解决的时候就不用声明异常，比如异常是运行期异常可以不需要声明,这样就默认使用JVM来解决异常。
3.异常有几种处理方式？
两种一种是throw抛出将异常抛给其他的使用者或者是Jvm，一种是try....catch，可进行灵活的处理。
4.什么是并发，什么是并行？
并发： 在一个时间段内 执行多个程序（快速切换）
并行： 在一个时间点上 同时执行多个程序
5.什么是进程，什么是线程？
进程：每一个应用程序进入内存执行的时候 至少会有一个进程；
线程：是进程中的执行单元，一个进程中至少有一个线程，每一个线程都有自己的线程任务。
6.run()方法和start()方法的区别？
run()定义的是线程任务，也就是线程运行的功能。对象名.start()是开始线程的方法，用了这个就可以运行run()方法里面的内容。
作者: MJ11 时间: 2018-8-17 21:59
1.throw和throws的区别？
throw是抛出异常，在方法体中声明；throws是声明异常在方法名的后面声明；
2.什么时候需要声明异常，什么时候不需要声明异常？
编译时需要声明异常，运行时不需要声明异常；
3.异常有几种处理方式？
两中处理方式：thorws(抛出异常)；
Try...catch(捕捉异常)；
4什么是并发，什么是并行？
并发：在一个时间段内 执行多个程序（快速切换）；
并行：在一个时间点上 同时执行多个程序；
5.什么是进程，什么是线程？
进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。
线程：
线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
6.run()方法和start()方法的区别？
run()是线程中要执行的方法体，继承线程类要重写run()方法，并将要执行的代码块放在run()方法中执行。 start()方法是线程的开启方法，调用这个方法后线程才能运行；
田浪
作者: 迪亚波罗 时间: 2018-8-17 22:00
1.throw和throws的区别？
throws是将异常对象抛给方法的调用者。
throw 一般跟new关键字，创建异常对象。参数为异常原因（可自行描述）。
2.什么时候需要声明异常，什么时候不需要声明异常？
不通过代码解决异常，而是将异常抛出或者是运行期异常的时候不需要声明异常。
3.异常有几种处理方式？
抛出或者捕获
4.什么是并发，什么是并行？
并发：快速切换、单个执行。
并行： 同时执行。
5.什么是进程，什么是线程？
进程是执行的程序，线程是进程的基本单元。
6.run()方法和start()方法的区别？
run（）方法重写线程的执行任务
start（）方法启动线程。
孙享
作者: 小悦悦 时间: 2018-8-17 22:01
1.
throw通常用在方法体中，当执行到throw语句时会中断，不会在执行下面的语句。
throws通常用来声明方法，用来指定可能会抛出的异常，如果发生了异常，就交给调用出处理。
2.当代码在编译时期发生异常需要声明，如果在运行期，或者在自己处理异常时不需要声明
3.通常有两种throws和try...catch..finally
4并发是处理器交替处理，多个事物同个时间段执行；
并行是处理器同时处理,多个事物同个时间点一起执行
5.什么是进程，什么是线程？
进程是执行的程序，线程是进程的基本单元。
6.run()方法和start()方法的区别？
run（）方法重写线程的执行任务
start（）方法启动线程。
--李翔
作者: zouyitao 时间: 2018-8-17 22:01
邹毅涛
1.throw和throws的区别？
throw在指定方法内调用指定异常，throws 将异常抛给调用者，直到JVM
2.什么时候需要声明异常，什么时候不需要声明异常？
编译时异常必须声明异常，运行时异常默认JVM处理
3.异常有几种处理方式？
有两种：throws和try……catch
4.什么是并发，什么是并行？
并发是在同一段时间内发生，并行是同一时刻。
5.什么是进程，什么是线程？
进程：每一个应用程序进入内存执行的时候 至少会有一个进程（描述一个程序从创建、运行、到销毁的过程
线程：属于进程中的执行单元，一个进程中至少有一个线程（多个线程），每一个线程都有自己的线程任务
6.run()方法和start()方法的区别？
run方法写的是线程实现的功能代码
start方法是JVM执行多线程调用run方法
作者: shenxiaogan 时间: 2018-8-18 08:40
1.throw和throws的区别？
throw用于自定义异常的抛出，throws是用于异常代码的处理
2.什么时候需要声明异常，什么时候不需要声明异常？
当遇到代码编译异常时需要声明异常，当代码是运行异常时不需要声明
3.异常有几种处理方式？
有三种；一是不处理，二是Throws抛给方法调用者，若是在main方法中就抛给JVM处理，三是try...catch在当前方法处理抛出，也有用到JVM
4.什么是并发，什么是并行？
并发是进程的线程在时间轴上交替运行，并行是进程的线程在时间轴上共同运行
5.什么是进程，什么是线程？
进程是应用程序，进程是应用程序中的功能单元，至少有一个
6.run()方法和start()方法的区别？
使用run()，则是单线程执行代码，使用start()，则是多线程执行代码
| 欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) |
黑马程序员IT技术论坛 X3.2 |