try{
// 监视可能出现异常的代码
}catch{异常类型1 变量}{
// 处理异常
}catch{异常类型2 变量}{
// 处理异常
}
- 第二中方式，可以处理异常，并且出现异常后代码也不会死亡，但是从理论上来说，这种方式不是最好的，上层调用者不能直接知道底层的执行情况！
方式三：在出现异常的地方把异常一层一层的抛出给最外层调用者，最外层调用者集中捕获处理
try{
// 可能出现异常的代码
}catch(Exception e){
e.printStackTrae(); //直接打印异常栈信息
}
-
这种方案最外层调用者可以知道底层执行的情况，同时程序在出现异常后也不会立即死亡，这是理论上最好的方案。
-
虽然异常有三种处理方式，但是开发中只要能解决你的问题，每种方式都可能用到！
1.4finally关键字
- 用在捕获处理的异常格式中，放在最后面
try{
//可能出现异常的代码！
}catch{Exception e}{
e.printStackTrace();
}finally{
// 无论代码是出现异常还是正常执行,最终一定要执行这里的代码！！
}
-
finally的作用：可以在代码执行完毕后进行资源的释放操作
-
资源都是实现了Closeable接口的，都自带close()关闭方法
-
try ： 出现1次
-
catch：出现0 - N 次(如果有finally那么 catch 可以没有)
-
finally：出现0 - 1 次
1.5自定义异常（了解）
Java已经为开发中可能出现的异常都设计了一个类来代表，但是在实际开发中，异常可能有无数中情况，Java无法为这个世界上所有的异常都定义了一个类。假如一个企业如果想为自己认为的某种业务问题定义成一个异常，就需要自己来自定义异常类。
1.4多线程(并发编程)
- 什么是进程？
答：程序是静止的，运行中的程序就是进程
- 进程的三个特征
-
独立性：进程与进程之间是相互独立的，彼此有自己独立内存区域
-
动态性：进程是运行中的程序，要动态的占用内存，CPU和网络等资源
-
并发性：CPU会分时轮询切换依次为每个进程服务，因为切换的速度非常快，给我们的感觉像是在同时执行，这就是并发性
-
并发：同一时刻同时有多个在执行
- 什么是线程？
答：线程是属于进程的，一个进程可以包含多个线程，这就是多线程
1.5线程的创建方式
多线程是很有用的，我们在进程中创建线程的方式有三种：
1.5.1继承Thread类继承Thread类的方式：
-
定义一个线程类继承Thread类
-
重写run()方法
-
创建一个新的线程对象
Thread t = new MyThread();
- 调用线程对象的start()方法启动线程
public class ThreadDemo {
// 启动后的ThreadDemo当成一个进程。
// main方法是由主线程执行的，理解成main方法就是一个主线程
public static void main(String[] args) {
// 3.创建一个线程对象
Thread t = new MyThread();
// 4.调用线程对象的start()方法启动线程,最终还是执行run()方法！
t.start();
for(int i = 0 ; i < 100 ; i++ ){
System.out.println(“main线程输出：”+i);
}
}
}
// 1.定义一个线程类继承Thread类。
class MyThread extends Thread{
// 2.重写run()方法
@Override
public void run() {
// 线程的执行方法。
for(int i = 0 ; i < 100 ; i++ ){
System.out.println(“子线程输出：”+i);
}
}
}
1.5.2实现Runnable接口-
创建一个线程任务类实现Runnable接口
-
重写run()方法
-
创建一个线程任务对象（注意：线程任务对象不是线程对象，只是执行线程的任务的）
Runnable target = new MyRunnable();
- 把线程任务对象包装成线程对象,且可以指定线程名称
// Thread t = new Thread(target);
Thread t = new Thread(target,“1号线程”);
- 调用线程对象的start()方法启动线程
public class ThreadDemo {
public static void main(String[] args) {
// 3.创建一个线程任务对象(注意：线程任务对象不是线程对象，只是执行线程的任务的)
Runnable target = new MyRunnable();
// 4.把线程任务对象包装成线程对象.且可以指定线程名称
// Thread t = new Thread(target);
Thread t = new Thread(target,“1号线程”);
// 5.调用线程对象的start()方法启动线程
t.start();
Thread t2 = new Thread(target);
// 调用线程对象的start()方法启动线程
t2.start();
for(int i = 0 ; i < 10 ; i++ ){
System.out.println(Thread.currentThread().getName()+"==>"+i);
}
}
}
// 1.创建一个线程任务类实现Runnable接口。
class MyRunnable implements Runnable{
// 2.重写run()方法
@Override
public void run() {
for(int i = 0 ; i < 10 ; i++ ){
System.out.println(Thread.currentThread().getName()+"==>"+i);
}
}
}
1.5.2.1Thread的构造器-
public Thread(){}
-
public Thread(String name){}
-
public Thread(Runnable target){}:分配一个新的Thread对象
-
public Thread(Runnable target,String name)：分配一个新的Thread对象,且可以指定新的线程名称
缺点：代码复杂一点
优点：
-
线程任务类只是实现了Runnable接口，可以继续继承其他类，而且可以继续实现其他接口(避免乐单继承的局限性)
-
同一个线程任务对象可以被包装成多个线程对象
- 定义一个线程任务类实现Callable接口，申明线程
《一线大厂Java面试题解析+后端开发学习笔记+最新架构讲解视频+实战项目源码讲义》
【docs.qq.com/doc/DSmxTbFJ1cmN1R2dB】 完整内容开源分享
返回的结果类型
-
重写线程任务类的call方法，这个方法可以直接返回执行的结果
-
创建一个Callable的线程任务对象
-
把Callable的线程任务对象包装成一个未来任务对象
-
把未来任务对象包装成线程对象
-
调用线程的start()方法启动线程
public class ThreadDemo {
public static void main(String[] args) {
// 3.创建一个Callable的线程任务对象
Callable call = new MyCallable();
// 4.把Callable任务对象包装成一个未来任务对象
// – public FutureTask(Callable callable)
// 未来任务对象是啥，有啥用？
// – 未来任务对象其实就是一个Runnable对象:这样就可以被包装成线程对象！
// – 未来任务对象可以在线程执行完毕之后去得到线程执行的结果。
FutureTask task = new FutureTask<>(call);
// 5.把未来任务对象包装成线程对象
Thread t = new Thread(task);
// 6.启动线程对象
t.start();
for(int i = 1 ; i <= 10 ; i++ ){
System.out.println(Thread.currentThread().getName()+" => " + i);
}
// 在最后去获取线程执行的结果,如果线程没有结果，让出CPU等线程执行完再来取结果
try {
String rs = task.get(); // 获取call方法返回的结果（正常/异常结果）
System.out.println(rs);
} catch (Exception e) {
e.printStackTrace();
}
}
}
// 1.创建一个线程任务类实现Callable接口，申明线程返回的结果类型
class MyCallable implements Callable{
// 2.重写线程任务类的call方法！
@Override
public String call() throws Exception {
// 需求：计算1-10的和返回
int sum = 0 ;
for(int i = 1 ; i <= 10 ; i++ ){
System.out.println(Thread.currentThread().getName()+" => " + i);
sum+=i;
}
return Thread.currentThread().getName()+“执行的结果是：”+sum;
}
}
1.5.4优劣点优点：全是优点
1.6线程的常用API
Thread 类的 API
-
public void setName(String name): 给当前线程取名字
-
public void getName(): 获取当前线程的名字
-
线程存在默认名称，子线程的默认名称是：Thread - 索引
-
主线程的默认名称是：main
-
public static Thread currentThread(): 获取当前线程对象，这个代码在哪个线程中，就得到哪个线程对象
-
public static void sleep(long time):让当前线程休眠多少毫秒再继续执行
-
public Thread(String name):创建对象并取名字
public class ThreadDemo {
// 启动后的ThreadDemo当成一个进程。
// main方法是由主线程执行的，理解成main方法就是一个主线程
public static void main(String[] args) {
// 创建一个线程对象
Thread t1 = new MyThread();
t1.setName(“1号线程”);
t1.start();
//System.out.println(t1.getName()); // 获取线程名称
Thread t2 = new MyThread();
t2.setName(“2号线程”);
t2.start();
//System.out.println(t2.getName()); // 获取线程名称
// 主线程的名称如何获取呢？
// 这个代码在哪个线程中，就得到哪个线程对象。
Thread m = Thread.currentThread();
m.setName(“最强线程main”);
//System.out.println(m.getName()); // 获取线程名称
for(int i = 0 ; i < 10 ; i++ ){
System.out.println(m.getName()+"==>"+i);
}
}
}
// 1.定义一个线程类继承Thread类。
class MyThread extends Thread{
// 2.重写run()方法
@Override
public void run() {
// 线程的执行方法。
for(int i = 0 ; i < 10 ; i++ ){
System.out.println(Thread.currentThread().getName()+"==>"+i);
}
}
}
线程休眠api
public class ThreadDemo02 {
public static void main(String[] args) {
for(int i = 0 ; i < 10 ; i++ ) {
System.out.println(i);
try {
// 项目经理让我加上这行代码
// 如果用户交钱了，我就去掉。
Thread.sleep(1000); // 让当前线程休眠1s.
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
通过Thread类的有参构造器为当前线程对象取名字
public class ThreadDemo03 {
// 启动这个类，这个类就是进程，它自带一个主线程，
// 是main方法，main就是一个主线程的执行！！
public static void main(String[] args) {
Thread t1 = new MyThread02(“1号线程”);
t1.start();
Thread t2 = new MyThread02(“2号线程”);
t2.start();
Thread.currentThread().setName(“主线程”);
for(int i = 0 ; i < 10 ; i++ ) {
System.out.println(Thread.currentThread().getName()+" => "+i);
}
}
}
// 1.定义一个线程类继承Thread。线程类并不是线程对象，用来创建线程对象的。
class MyThread02 extends Thread{
public MyThread02(String name) {
// public Thread(String name):父类的有参数构造器
super(name); // 调用父类的有参数构造器初始化当前线程对象的名称！
}
// 2.重写run()方法
@Override
public void run() {
for(int i = 0 ; i < 10 ; i++ ) {
System.out.println(Thread.currentThread().getName()+" => "+i);
}
}
}
1.7线程安全
线程安全问题：多个线程同时操作同一个共享资源的时候可能会出现线程安全问题
1.7线程同步_同步代码块
-
线程同步的作用：就是为了解决线程安全问题，让多个线程实现先后依次访问共享资源，这样就解决了安全问题
-
线程安全：多个线程同时操作同一个共享资源的时候可能会出现线程安全问题
-
线程同步的做法：加锁(就是把共享资源进行上锁，每次只能一个线程进入访问完毕以后，其他线程才能进来)
-
线程同步的方法：
-
同步代码块
-
同步方法
-
lock 显示锁
同步代码块作用：是把出现线程安全问题的核心代码给上锁，每次只能一个线程进入，执行完毕之后自动解锁，其他线程才可以进来执行
