异常，多线程，自定义注解

最新推荐文章于 2024-02-05 14:01:38 发布
最新推荐文章于 2024-02-05 14:01:38 发布
阅读量194 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48427846/article/details/107390513
版权

1.定义

异常：在Java语言中，将程序执行中发生的不正常情况称为“异常”。
2.异常的分类

从程序执行过程可分为两类

编译时异常：执行javac.exe命名时，可能出现的异常；
是指编译器不要求强制处置的异常。一般是指编程时的逻辑错误，是程序员应该积极避免其出现的异常。java.lang.RuntimeException类及它的子类都是运行时异常。
运行时异常：执行java.exe命名时，出现的异常。
是指编译器要求必须处置的异常。即程序在运行时由于外界因素造成的一般性异常。编译器要求Java程序必须捕获或声明所有编译时异常。
2.1运行时异常举例

//ArithmeticException
public void test6(){
int a = 10;
int b = 0;
System.out.println(a / b);
}

//InputMismatchException

public void test5(){
	Scanner scanner = new Scanner(System.in);
	int score = scanner.nextInt();
	System.out.println(score);
	
	scanner.close();
}

//NumberFormatException

public void test4(){
	
	String str = "123";
	str = "abc";
	int num = Integer.parseInt(str);
	
	
	
}

//ClassCastException

public void test3(){
	Object obj = new Date();
	String str = (String)obj;
}

//IndexOutOfBoundsException

public void test2(){

	//StringIndexOutOfBoundsException
	String str = "abc";
	System.out.println(str.charAt(3));
}

2.2编译时运行异常举例

public void test7(){
File file = new File(“hello.txt”);
FileInputStream fis = new FileInputStream(file);

	int data = fis.read();
while(data != -1){
		System.out.print((char)data);
	        data = fis.read();
	}

	fis.close();
	
}

异常处理机制
一：异常处理的两种方式

方式一：try-catch-finally
方式二：throws + 异常类型
try-catch-finally处理模式
//异常处理是通过try-catch-finally语句实现的。

try{
…//可能产生异常的代码

}catch(ExceptionName1e){

    ......//当产生ExceptionName1型异常时的处置措施
        }catch(ExceptionName2e){

    .....//当产生ExceptionName2型异常时的处置措施
}[finally{
    ......//无论是否发生异常，都无条件
    
    }]

try
捕获异常的第一步是用try{…}语句块选定捕获异常的范围，将可能出现异常的代码放在try语句块中。
catch
在catch语句块中是对异常对象进行处理的代码。每个try语句块可以伴随一个或多个catch语句，用于处理可能产生的不同类型的异常对象。
常用的异常对象处理的方式： ① String getMessage() ② printStackTrace()
throws + 异常类型处理方式
如果一个方法(中的语句执行时)可能生成某种异常，但是并不能确定如何处理这种异常，则此方法应显示地声明抛出异常，表明该方法将不对这些异常进行处理，而由该方法的调用者负责处理。在方法声明中用throws语句可以声明抛出异常的列表，throws后面的异常类型可以是方法中产生的异常类型，也可以是它的父类。

注意：

"throws + 异常类型"写在方法的声明处。指明此方法执行时，可能会抛出的异常类型。
一旦当方法体执行时，出现异常，仍会在异常代码处生成一个异常类的对象，此对象满足throws后异常类型时，就会被抛出。异常代码后续的代码，就不再执行！

importjava.io.*;

public class ThrowsTest {

    public static void main(String[] args) {
            
           ThrowsTest t= newThrowsTest();

            try{
                   t.readFile();
                } catch(IOException e) {
                   e.printStackTrace();

                    }
        }

public void readFile() throws IOException {

        FileInputStream in= newFileInputStream("atguigushk.txt");

         int b;
         b= in.read();

        while(b!= -1) {
            
                System.out.print((char) b);
        
                b= in.read();
           }
            in.close();
       }

}
手动抛出异常
Java异常类对象除在程序执行过程中出现异常时由系统自动生成并抛出，也可根据需要使用人工创建并抛出。

首先：首先要生成异常类对象，然后通过throw语句实现抛出操作(提交给Java运行环境)。

IOExceptione=newIOException();

     throwe;

可以抛出的异常必须是Throwable或其子类的实例。下面的语句在编译时将会产生语法错误：

throw new String(“want to throw”)；
用户自定义异常
一般地，用户自定义异常类都是RuntimeException的子类。
自定义异常类通常需要编写几个重载的构造器。
自定义异常需要提供serialVersionUID
自定义的异常通过throw抛出。
自定义异常最重要的是异常类的名字，当异常出现时，可以根据名字判断异常类型。
创建多线程的两种方式
继承Thread类的方式
一：实现步骤

创建一个继承股Thread的子类
重写Thread类的run（）方法
创建Thread类的子类对象
通过子类对象调用strat（）开启线程并调用run（）方法；
/**

  • @author 宇戰天
  • @description：遍历1-40之内的偶数
  • @create2020-07-10-16:22
    */

//1.创建一个继承与Thread的子类
class MyThread extends Thread {
//2.重写Thread的run()方法

@Override
public void run() {

    for (int i = 0; i < 40; i++) {
        if(i%2 ==0){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }

    }
}

}
public class ThreadTest {

public static void main(String[] args) {
    //3创建Thread的子类对象
    MyThread t1 = new MyThread();

    MyThread t2 = new MyThread();

    //4通过此对象实例调用start()方法开启线程
    t1.start();

    t2.start();

    //创建对比主线程
    for (int i = 0; i < 40; i++) {
        if (i % 2 ==0){
            System.out.println(Thread.currentThread().getName()+":"+i+"  main");
        }

    }




}

}

运行结果

线程的常用方法
start(): 启动线程，并执行对象的run()方法；
run(): 线程在被调度时执行的操作；
getName(): 返回线程的名称；
currentThread：返回执行当前代码的线程；
setName(String name):设置该线程名称；
/**

  • @author 宇戰天

  • @description：

  • 方式一：

  • 设置当前线程的名字setName();

  • 为子线程时对象实例.setName(线程名);设置该线程名

  • 在main方法中设置线程名时需要先通过currentThread()获取当前代码的线程在设置线程名

  • Thread.currentThread().setName(“线程名”);

  • 方式二：

  • 在子类对象中添加Thread(String)的构造器在实例化线程时直接初始化线程名

  • @create2020-07-10-18:42
    */
    public class SetNameMethod {

    public static void main(String[] args) {
    //实例化Thread的子类对象
    UpdateThreadName u1 = new UpdateThreadName();

     u1.setName("我是子线程");

 //子类对象调用start()开启线程并调用器run（）方法
 u1.start();

 //添加主线程对比项
 Thread.currentThread().setName("我是主线程");

 for (int i = 0; i < 20; i++) {

     if (i % 2 == 0){
         System.out.println(Thread.currentThread().getName() + " " + i);
     }
 }

    }
    }

//创建Thread的子类对象
class UpdateThreadName extends Thread{

//提供构造器

public UpdateThreadName() {
}

public UpdateThreadName(String name) {
    super(name);
}

//重写run();
@Override
public void run() {
for (int i = 0; i < 20; i++) {

        if (i % 2 == 0){
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
    }
}

}

运行结果

  1. yield（）；释放当前cpu 的执行权限

/**

  • @author 宇戰天

  • @description：

  • yield()释放当前CPU的执行权限

  • @create2020-07-10-19:03
    */
    public class UserYield {

    public static void main(String[] args) {

     YieldMethod y1 = new YieldMethod();
 y1.setName("子线程");
 y1.start();

 for (int i = 0; i < 50; i++) {

     if (i % 2 != 00){

         System.out.println(Thread.currentThread().getName() + "  " + i);

     }

 }

    }

}

class YieldMethod extends Thread{

@Override
public void run() {

    for (int i = 0;i <100;i++){

        if (i % 2 ==0){
            System.out.println(Thread.currentThread().getName() + "  " + i);
        }
        if (i ==20){
            yield();
        }
    }

}

}

join()：当某个程序执行流中调用其他线程的join() 方法时，调用线程将被阻塞，直到join() 方法加入的join 线程执行完为止；
isAlive()：返回boolean，判断线程是否还活着
sleep(long millis)：令当前活动线程在指定时间段内放弃对CPU控制,使其他线程有机会被执行,时间到后重排队。
/**

  • @author 宇戰天

  • @description：

  • join()方法在线程a中调用线程b的join()方法，此时线程a就进入停止状态知道线程b执行完为止
    *sleep();让当前线程休眠，只等时间内为阻塞状态

  • isAlive()判断当前线程是否存活

  • @create2020-07-10-19:28
    */
    public class JoinMethod {

    public static void main(String[] args) {

     JoinIn method23 = new JoinIn();

 method23.setName("线程b");
 method23.start();

 Thread.currentThread().setName("线程a");
 for (int i = 0; i < 50; i++) {

     System.out.println(Thread.currentThread().getName() + "  " + i);
     if (i==25){
         try {
             //在在线程a中调用线程b的join();
             method23.join();
         } catch (InterruptedException e) {
             e.printStackTrace();
         }

     }

 }
 //判断当前线程是否存活
 System.out.println(method23.isAlive());

    }
    }

class JoinIn extends Thread{

@Override
public void run() {
    for (int i = 0;i<50;i++){

        //当前线程休眠时间
        try {
            sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(Thread.currentThread().getName() + "   " + i);
    }
}

}

线程的优先级
线程的优先级等级

MAX_PRIORITY：10
MIN _PRIORITY：1
NORM_PRIORITY：5（默认优先级）
如何设置线程的优先级
getPriority() ：返回线程优先值
setPriority(intnewPriority) ：改变线程的优先级
注意
线程创建时继承父线程的优先级；
低优先级只是获得调度的概率低，并非一定是在高优先级线程之后才被调用
创建线程的方式二：实现Runnable接口
实现思路
1.创建一个实现Runnable接口的实现类；
2.实现类实现Runnable中的抽象方法run();
3.创建实现类的对象；
4.将此实现类作为参数传递给Thread的构造器中并创建Thread类的对象；
5.通过Thread类的对象调用start()启动线程并调用Runnable类型的target的run();

/**

  • @author 宇戰天
  • @description：
  • 创建多线程的第二种方式：实现Runnable接口
  • 1.创建一个实现Runnable接口的实现类；
  • 2.实现类实现Runnable中的抽象方法run();
  • 3.创建实现类的对象；
  • 4.将此实现类作为参数传递给Thread的构造器中并创建Thread类的对象；
  • 5.通过Thread类的对象调用start()启动线程并调用Runnable类型的target的run();
  • @create2020-07-10-21:47
    */

//1.创建一个实现Runnable接口的实现类
class Thread2 implements Runnable{
//2.实现类实现Runnable中的抽象方法run();
@Override
public void run() {
for (int i = 0; i < 40; i++) {

        System.out.println(Thread.currentThread().getName() + " " + i);

    }
}

}
public class ImplementsThreadSecondMethod {

public static void main(String[] args) {
    //3.创建实现类的对象
    Thread2 t2 = new Thread2();
    //4.将此实现类作为参数传递给Thread的构造器中并创建Thread类的对象
    Thread thread = new Thread(t2);
    thread.setName("线程");
    //5.通过Thread类的对象调用start()启动线程并调用Runnable类型的target的run();
    thread.start();
}

}

线程安全
在java中我们通过同步机制来解决线程的安全问题；解决线程通行常用的三种方法分别为lock锁方式、同步代码块、同步方法

一：同步代码块方式解决线程安全问题
定义
synchronized (同步监听器){

		//需要被同步的代码

}

说明
操作共享数据的代码为需要被同步的代码
共享数据多个线程共同操作的变量
同步监听器：俗称锁任何一个对象都可以充当锁，但是多个线程必须共用同一个锁。
实现Runnable接口方式

/**

  • @author 宇戰天
  • @description：

*通过实现Runnable接口方式创建三个线程实现卖票功能

  • 步骤：
  • 1.创建一个Runnable接口的类；
  • 2.实现Runnable中的抽象方法run（）；
  • 3.创建实现对象
  • 4.创建Thread对象，此将实现Runnable的子类对象作为参数传递到Thread的构造器中；
  • 5.通过Thread对象调用start（）开启线程
  • 用同步代码块方式解决线程安全问题
  •   synchronized(监听器) {

  •          需要同步打代码

  • }
  • @create2020-07-12-12:31
    */

public class SellTicketTest {

public static void main(String[] args) {
    //3.创建实现的对象
    TicketWindow chengDu = new TicketWindow();

    //4.创建Thread对象，此将实现Runnable的子类对象作为参数传递到Thread的构造器中

    Thread sellWindows1 = new Thread(chengDu);
    Thread sellWindows2 = new Thread(chengDu);
    Thread sellWindows3= new Thread(chengDu);

    //设置线程名
    sellWindows1.setName("一号窗口");
    sellWindows2.setName("二号窗口");
    sellWindows2.setName("三号窗口");

    //5.通过Thread对象调用start（）开启线程
    sellWindows1.start();
    sellWindows2.start();
    sellWindows3.start();

}

}
//1.传建一个实现Runnable接口的子类
class TicketWindow implements Runnable{
//售票数量（多个线程共享此数据）
private int ticket =100;

//定义同步监听器-->锁
Object obj = new Object();

//2.重写Runnable中的抽象方法run（）
@Override
public void run() {
    while (true){

        synchronized(obj) {

            if (ticket >0){
//一秒后开启线程为其他线程执行抢占CPU资源提供条件
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println(Thread.currentThread().getName() + " 卖票，票的编号为：" + ticket);

                ticket--;
            }else{
                break;
            }
        }

    }
}

}

继承Thread类

**

  • @author 宇戰天

  • @description：

  • 通过继承Thread方式创建三个进程实现卖票功能

  • 1.创建继承Thread的子类；

  • 2.重写T和read中的run（）;

  • 3.创建Thread的子类对象；

  • 4.通过子类对象调用start（）方法开启线程

  • 通过synchronized(同步监视器){

  • 需要被同步的代码

  • }

  • 解决线程安全问题

  • @create2020-07-12-13:28
    */
    public class SellTicketTest1 {

    public static void main(String[] args) {
    //3.创建Thread类的子类的对象
    sellWindows1 t1 = new sellWindows1();
    sellWindows1 t2 = new sellWindows1();
    sellWindows1 t3 = new sellWindows1();

     //更改线程名
 t1.setName("窗口1");
 t2.setName("窗口2");
 t3.setName("窗口3");

 //4.通过此子类对象调用start（）开启线程
 t1.start();
 t2.start();
 t3.start();

    }
    }

//1.创建一个继承于Thread的子类
class sellWindows1 extends Thread{
//所有对象共享此变量
private static int ticket = 100;
//创建同步锁
private static Object obj = new Object();
//2.重写Thread中的run
@Override
public void run() {

    while (true){

        synchronized (obj){
            if (ticket>0){

                    //提高其他线程出现的几率
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " 卖票，票号为：" + ticket);
                ticket--;

            }else{
                break;
            }
        }

    }
}

}

同步方法解决线程安全问题
实现Runnable接口方式

/**

  • @author 宇戰天

  • @description：

  • 同步方法解决线程安全问题

  • @create2020-07-12-14:13
    */
    public class SellTicketTest3 {

    public static void main(String[] args) {
    //3.创建实现的对象
    TicketWindow3 chengDu = new TicketWindow3();

     //4.创建Thread对象，此将实现Runnable的子类对象作为参数传递到Thread的构造器中

 Thread sellWindows1 = new Thread(chengDu);
 Thread sellWindows2 = new Thread(chengDu);
 Thread sellWindows3 = new Thread(chengDu);

 //设置线程名
 sellWindows1.setName("一号窗口");
 sellWindows2.setName("二号窗口");
 sellWindows2.setName("三号窗口");

 //5.通过Thread对象调用start（）开启线程
 sellWindows1.start();
 sellWindows2.start();
 sellWindows3.start();

    }

}
//1.传建一个实现Runnable接口的子类
class TicketWindow3 implements Runnable{
//售票数量（多个线程共享此数据）
private int ticket =100;

//2.重写Runnable中的抽象方法run（）
@Override
public void run() {
    while (true) {

        show();

    }
}
private synchronized void show(){

    if (ticket >0){
        //一秒后开启线程为其他线程执行抢占CPU资源提供条件
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(Thread.currentThread().getName() + " 卖票，票的编号为：" + ticket);

        ticket--;
    }
}

}

继承Thread子类的方式

/**

  • @author

  • @description：

  • @create2020-07-12-14:35
    */
    public class sellTicketTest4 {

    public static void main(String[] args) {
    //3.创建Thread类的子类的对象
    sellWindows4 l1 = new sellWindows4();
    sellWindows4 l2 = new sellWindows4();
    sellWindows4 l3 = new sellWindows4();

     //更改线程名
 l1.setName("窗口1");
 l2.setName("窗口2");
 l3.setName("窗口3");

 //4.通过此子类对象调用start（）开启线程
 l1.start();
 l2.start();
 l3.start();

    }
    }

//1.创建一个继承于Thread的子类
class sellWindows4 extends Thread{
//所有对象共享此变量
private static int ticket = 100;

//2.重写Thread中的run
@Override
public void run() {

    while (true){

        show();

    }
}

private static synchronized  void show(){
    if (ticket>0){

        //提高其他线程出现的几率
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " 卖票，票号为：" + ticket);
        ticket--;

    }

}

}

线程通信
wait() 与notify() 和notifyAll()

wait()：令当前线程挂起并放弃CPU、同步资源并等待，使别的线程可访问并修改共享资源，而当前线程排队等候其他线程调用notify()或notifyAll()方法唤醒，唤醒后等待重新获得对监视器的所有权后才能继续执行
notify()：唤醒正在排队等待同步资源的线程中优先级最高者结束等待
notify()：唤醒正在排队等待同步资源的线程中优先级最高者结束等待
注意
这三个方法只有在synchronized方法或synchronized代码块中才能使用

一：定义
Java 注解（Annotation）又称 Java 标注，是 JDK5.0 引入的一种注释机制。
Java 语言中的类、方法、变量、参数和包等都可以被标注。和 Javadoc 不同，Java 标注可以通过反射获取标注内容。在编译器生成类文件时，标注可以被嵌入到字节码中。Java 虚拟机可以保留标注内容，在运行时可以获取到标注内容 。 当然它也支持自定义 Java 标注。

二： 内置注解
作用在代码的注解是

@Override - 检查该方法是否是重写方法。如果发现其父类，或者是引用的接口中并没有该方法时，会报编译错误。
@Deprecated - 标记过时方法。如果使用该方法，会报编译警告。
@SuppressWarnings - 指示编译器去忽略注解中声明的警告。
作用在其他注解的注解(或者说 元注解)是:

@Retention - 标识这个注解怎么保存，是只在代码中，还是编入class文件中，或者是在运行时可以通过反射访问。
@Documented - 标记这些注解是否包含在用户文档中。
@Target - 标记这个注解应该是哪种 Java 成员。
@Inherited - 标记这个注解是继承于哪个注解类(默认 注解并没有继承于任何子类)
自定义注解
① 注解声明为：@interface
② 内部定义成员，通常使用value表示
③ 可以指定成员的默认值，使用default定义
④ 如果自定义注解没成员，表明是一个标识作用。

weixin_48427846
关注
自定义注解+反射+AOP+异步多线程统一日志管理
u014474768的博客
03-05 168
2.异步工厂直接生成异步任务，配合自定义间隔时间的线程池使用，每次TimeTask，每次间隔10毫秒做一次操作，多线程来完成。标准：yml文件读取线程池配置【写个类封装 专门读取配置】 跟主业务无关的 按面向对象思想封装OOP。这里当请求过来后5-10ms后才启动异步定时任务的线程去插入日志，有点时间间隔，不要让系统负担太重。线程池：主业务记个日志，异步需要给系统有个间隔切换，一般10ms。线程池全局只能有1个，类似一个大别墅，只有一个池。高大上：分布式配置中心+动态线程池。高并发下的异步线程记录。
使用自定义注解,动态代理和多线程模拟计算
weixin_43117331的博客
07-11 239
在计算类上添加自定义注解,通过扫描注解得到需要计算的类,开启多线程通过动态代理执行该类的计算方法
SpringBoot 中的多线程事务处理 一个自定义注解直接搞定！
最新发布
ringBey的博客
02-05 589
SpringBoot 中的多线程事务处理 一个自定义注解直接搞定！
Java 异常 -- 自定异常 -- 多线程
qq_44804064的博客
03-25 198
案例1：自定义年龄异常 需求: 创建一个Person类,提供get/set方法, 在setAge方法中判断年龄是否符合(0-130)这个范围, 如果不符合抛出一个对象,提示:年龄不符合! a.我们需要自定义异常,来描述年龄不在0-130范围这种情况 建立一个自定义异常类：AgeOutOfRangeException public class AgeOutOfRangeException extends Exception { public AgeOutOfRangeException(){}
自己写一个Spring中的多线程 @Async 注解
Javaer
09-24 311
手写@Async异步注解 思路：通过Aop拦截只要在我们方法上有使用到我们自己定义的异步注解，我们就单独的开启一个异步线程去执行目标方法。 1.自定义一个注解 /** * @author 王泽 */ @Target({ElementType.TYPE, ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface MyAsync { String value() default "";
spring boot注解事务+多线程
01-25
同时，Spring Boot提供了多种工具来管理和控制多线程，如ThreadPoolTaskExecutor，它允许我们自定义线程池参数，如核心线程数、最大线程数、线程存活时间等。例如： ```java @Configuration public class ...
Spring @Async 注解多线程导致Spring的注解@Transactional失效问题
ssmaaa的博客
02-20 3749
本文Spring @Async 注解多线程导致Spring的注解@Transactional失效与多数据源切换问题！ 问题：多线程为什么会导致事务注解@Transactional失效 实现AOP的方法有动态代理、编译期，类加载期织入等等，Spring实现AOP的方法则就是利用了动态代理机制，正因如此，才会导致某些情况下@Async和@Transactional不生效。 @Async注解使用如下 @EnableAsync //添加此注解开启异步调用（可用在配置类上，也可在启动类上标注） public
SpringBoot 使用自定义注解（基于AOP） 实现操作日志管理
最近学习目标：MySQL，Redis
11-10 1911
操作日志的记录 因为我们不光要记录代码的运行，如（logback log4j），而且还应该记录用户的行为（Controller 请求日志），这叫做业务运行日志。 业务运行日志的作用 记录用户的行为 用于后续的分析 记录用户的所有的操作 日志实现的思路 1.我们需要记录哪些数据（谁在什么时间干了什么事情，结果如何）？ 数据要存入到哪里（存储到数据库表，推送到指定日志存储服务，打印到日志文件等）？ 2.在项目中什么位置记录（一般在Controller请求，进行around 环绕增强） 如何实现记录
若依管理系统——自定义注解使用切面记录操作日志
DreamsArchitects的博客
09-28 4880
目录一、介绍二、登录日志记录分析2.1 异步定时任务管理器（线程池）2.2 异步工厂（产生任务用）三、用户操作行为记录分析3.1 定义注解3.2 定义切面3.3 使用注解四、源码SQL 一、介绍 系统访问记录表： 操作日志记录表： 二、登录日志记录分析 2.1 异步定时任务管理器（线程池） 无论登录成功还是失败，都会用一个异步的任务AsyncManager.me().execute()来保存登录结果： 通过SpringUtils工具类的getBean方法获得定时任务线程池对象，(也可以通过@Auto
Java中的异常及处理，自定义异常，线程 D190328
xc965746550的博客
03-28 382
Java中的异常及处理，自定义异常，线程 D190328 在实际应用中经常会遇到，应用范围广 01.第一章：异常_概念： 1).什么是“异常”：指程序在运行过程中遇到了一些无法处理的情况，这时JVM会向控制台打印错误信息，并停止程序。 这不是我们想看到的结果。基于此，Java为我们提供了一种“异常处理机制”可以使我们程序在发生异常情况时， 可以跳过异常的代码，继续向下执行。 2).JVM处理异常的...
Spring Boot 中的多线程事务处理太繁琐？一个自定义注解直接搞定！
m0_71777195的博客
06-25 1577
注解开启多线程,，并通过自定义注解和AOP实现的多线程事务，避免繁琐的手动提交/回滚事务 (CV即用、参数齐全、无需配置)原因：数据库连接spring是放在threadLocal里面，多线程场景下，拿到的数据库连接是不一样的，即是属于不同事务。用在调用方，其参数为必填，参数值为本方法中调用的方法开启的线程数，如：在这个方法中调用的方法中有2个方法用。的线程打开入口前，所有调用 await 的线程都一直在入口处等待。用在被调用方(开启线程的方法)，无需传入参数。即可，其中注解中的参数为自定义线程池的名称。
Oracle - 数据更新 - 事务
chenglc1612的博客
05-31 296
Oracle - 数据更新 - 事务 /* 事务 事务是为了控制数据异步访问所使用的一种技术 就类似于java中的锁机制 synchronized，只不过功能更加强大 事务不能进行嵌套，当我们开启一个事务的之后作的每一次dml语句都属于这个事务 ...
自定义注解实现springboot 多线程事务(基于@Async注解的多线程)
weixin_69672118的博客
11-14 4274
本文是基于springboot的@Async注解开启多线程, 并通过自定义注解和AOP实现的多线程事务, 避免繁琐的手动提交/回滚事务 (CV即用, 参数齐全, 无需配置)
Spring 之 @Transaction 详解
热门推荐
岁月安然
05-12 2万+
介绍 @Transaction 是 Spring 提供用来控制事务回滚/提交的一个注解，让我们从编程式注解转换到声明式注解。在这里就不做过多的撰述，今天主要来看下 @Transaction 里面的属性使用。 作用域 @Transaction 可以写在类、接口、方法上 当标注在类上的时候：表示给该类所有的 public 方法添加上 @Transaction 注解 当标注在接口上的时候：Spring 建议不要在接口或者接口方法上使用该注解，因为这只有在使用基于接口的代理时它才会生效。像 CGLib 动
使用@Async注解创建多线程，自定义线程池
weixin_30650039的博客
05-03 776
说明 使用@Async注解创建多线程非常的方便，还可以通过配置，实现线程池。比直接使用线程池简单太多。而且在使用上跟普通方法没什么区别，加上个@Async注解即可实现异步调用。 用法 AsyncTask.java @Component public class AsyncTask { private static final Logger LOG = LoggerFactory....
利用动态代理+注解 实现子线程中执行方法
wen_1992的博客
11-16 1881
要实现的功能： 这里有一个类MySubject，我希望MySubject类中的方法凡是带@AsynMethod注解的方法都用子线程进行处理，无@AsynMethod注解都正常在主线程中执行即可如下图： 思路：使用自定义注解+动态代理实现此功能所需的知识： 注解的基础知识：自定义注解入门 动态代理的官方文档：ProxyBuilder的用法 主要代码： 注解的实现代码：@Retention(
注解和多线程——JAVA
Angels_Descent的博客
06-09 1113
@月月鸟 注解的基本概念 注解(元数据)为我们在代码中添加信息提供一种形式化的方法，我们可以在某个时刻非常方便的使用这些数据。将的通俗一点，就是为这个方法增加的说明或功能。例如：@Overvide这个注解就用来说明这个方式重写父类的。 JDK提供的注解 Java目前内置了三种注解@Override、@Deprecated、@SuppressWarnnings @Override：用于标识方法，...
**线程里面使用注解(线程里面spring使用注解无法注入值的解决办法)**
Awsmsniper的博客
12-17 1万+
今天在使用SSM框架(spring/springmvc/mybatis)进行开发时，自己也是第一次使用，所以遇到的问题也比较多啊·········我今天是在一条线程里面使用注解时，发现一直报空指针异常，仔细看了一下发现使用注解时并没有注入值，所以才一直空指针异常····· 再仔细对比一下之前我自学时的代码，发现调用流程也没有错，搞了半天也没找出什么原因······最后想了一下，我是启动服务器的时候
Java注解详解：从基础到自定义注解
教程涵盖了Java面向对象、异常处理、数组、常用类、集合框架、输入输出（IO）流、线程、反射机制等内容，并基于最新的Java 13版本进行讲解。视频教学风格流畅，逻辑清晰，适合希望巩固Java SE基础知识的开发者。" ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值