事务、定时任务、多线程

已于 2022-09-19 20:40:04 修改
阅读量571 收藏
点赞数
分类专栏： # Spring 文章标签： java spring 开发语言
于 2022-09-16 01:50:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Liu_wen_wen/article/details/126882442
版权

事务、定时任务、多线程

1： 定时任务：

代码结构布局：

在这里插入图片描述

运行结果：

在这里插入图片描述

在这里插入图片描述

代码如下：

pom.xml:

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>org.example</groupId>
  <artifactId>Aop_0914_SecondStage</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>Aop_0914_SecondStage Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <maven.compiler.source>8</maven.compiler.source>
    <maven.compiler.target>8</maven.compiler.target>
    <servlet.version>4.0.1</servlet.version>
    <jsp.version>2.2</jsp.version>
    <jstl.version>1.2</jstl.version>
    <spring.version>5.3.14</spring.version>
    <commons-dbcp.version>1.4</commons-dbcp.version>
    <mybatis.version>3.4.6</mybatis.version>
    <mybatis-spring.version>1.3.3</mybatis-spring.version>
    <mysql-connector-java.version>8.0.11</mysql-connector-java.version>
    <fastjson.version>1.2.78</fastjson.version>
  </properties>
  <dependencies>
    <!--  添加javaEE支持  -->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
    </dependency>
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>${servlet.version}</version>
      <!--  provided只在编译时支持，发布时不拷贝文件  -->
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>jsp-api</artifactId>
      <version>${jsp.version}</version>
      <!--  provided只在编译时支持，发布时不拷贝文件  -->
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>jstl</groupId>
      <artifactId>jstl</artifactId>
      <version>${jstl.version}</version>
    </dependency>
    <!-- 引入spring基础模块 -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <!--dbcp连接池  -->
    <dependency>
      <groupId>commons-dbcp</groupId>
      <artifactId>commons-dbcp</artifactId>
      <version>${commons-dbcp.version}</version>
    </dependency>
    <!--mybatis-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>${mybatis.version}</version>
    </dependency>
    <!--  mybatis spring整合  -->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>${mybatis-spring.version}</version>
    </dependency>
    <!-- mybatis插件PageHelper -->
    <dependency>
      <groupId>com.github.pagehelper</groupId>
      <artifactId>pagehelper</artifactId>
      <version>5.1.0</version>
    </dependency>
    <!--通用mapper插件-->
    <dependency>
      <groupId>com.github.abel533</groupId>
      <artifactId>mapper</artifactId>
      <version>3.0.1</version>
    </dependency>
    <!--  mysql驱动类  -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>${mysql-connector-java.version}</version>
    </dependency>
    <!-- fastjson处理json数据 -->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>fastjson</artifactId>
      <version>${fastjson.version}</version>
    </dependency>
    <!-- lombok 简化实体内容 -->
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>1.18.24</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.11.2</version>
    </dependency>
    <dependency>
      <groupId>com.sun.mail</groupId>
      <artifactId>javax.mail</artifactId>
      <version>1.5.6</version>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
      <version>1.7.30</version>
    </dependency>
    <dependency>
      <groupId>com.github.xuwei-k</groupId>
      <artifactId>html2image</artifactId>
      <version>0.1.0</version>
    </dependency>
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.9.8</version>
    </dependency>
<!--    <dependency>-->
<!--      <groupId>org.slf4j</groupId>-->
<!--      <artifactId>slf4j-simple</artifactId>-->
<!--      <version>1.7.25</version>-->
<!--    </dependency>-->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.13.2.2</version>
    </dependency>
    <!--logback记录文件日志-->
    <dependency>
      <groupId>org.logback-extensions</groupId>
      <artifactId>logback-ext-spring</artifactId>
      <version>0.1.4</version>
    </dependency>
    <!--数据校验-->
    <dependency>
      <groupId>javax.validation</groupId>
      <artifactId>validation-api</artifactId>
      <version>2.0.1.Final</version>
    </dependency>
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-validator</artifactId>
      <version>6.1.0.Final</version>
    </dependency>

    <!--文件生成-->
    <!-- https://mvnrepository.com/artifact/org.apache.poi/poi -->
    <dependency>
      <groupId>org.apache.poi</groupId>
      <artifactId>poi</artifactId>
      <version>3.17</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.apache.poi/poi-ooxml -->
    <dependency>
      <groupId>org.apache.poi</groupId>
      <artifactId>poi-ooxml</artifactId>
      <version>3.17</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.apache.poi/poi-ooxml-schemas -->
    <dependency>
      <groupId>org.apache.poi</groupId>
      <artifactId>poi-ooxml-schemas</artifactId>
      <version>3.17</version>
    </dependency>
    <!--发送邮件-->
    <dependency>
      <groupId>com.sun.mail</groupId>
      <artifactId>jakarta.mail</artifactId>
      <version>1.6.7</version>
    </dependency>
    <!--定时任务所需要的包-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context-support</artifactId>
      <version>5.3.1</version>
    </dependency>
    <dependency>
      <groupId>org.quartz-scheduler</groupId>
      <artifactId>quartz</artifactId>
      <version>2.2.1</version>
    </dependency>
    
  </dependencies>
</project>

spring-task.xml:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:task="http://www.springframework.org/schema/task"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task.xsd">
    <!--扫描包-->
    <context:component-scan base-package="com.util"/>
    <!--用xml方式配置定时任务-->
<!--    <task:scheduled-tasks>-->
<!--        <task:scheduled ref="myTaskJob" method="task" cron="*/2 * * * * *"/>-->
<!--    </task:scheduled-tasks>-->

    <!--注解方式实现定时任务-->
    <!--开启注解配置-->
    <context:annotation-config />
    <!--开启这个配置，spring才能识别@Scheduled注解-->
    <task:annotation-driven/>
</beans>

MyTaskJob:

package com.util;

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import java.time.LocalDateTime;

@Component("myTaskJob")
public class MyTaskJob {
    //定义定时任务方法
    public void task(){
        System.out.println("这是一个定时任务,发短信，发邮件，数据库备份:"+ LocalDateTime.now());
    }

    //定义定时任务方法
    @Scheduled(cron = "*/5 * * * * *")
    public void task2(){
        System.out.println("这是一个定时任务mytask2,发短信，发邮件，数据库备份:"+ LocalDateTime.now());
    }
}

MyTest6 :

package com.test3;

import com.util.MyTaskJob;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;


public class MyTest6 {
    public static void main(String[] args) {
        //定时任务测试
        ApplicationContext ac = new ClassPathXmlApplicationContext("spring-task.xml");
        //MyTaskJob myTaskJob = ac.getBean(MyTaskJob.class);

    }
}

2： 多线程 三种方式：

①代码结构布局：

在这里插入图片描述

运行结果：

在这里插入图片描述

代码如下：

MyThread ：

package com.aaa.test;

/**
 * 实现多线程编程的第一种方式:继承Thread类
 * @author: hy
 * @create: 2022-09-15 11:02:24
 */
public class MyThread extends Thread{

    /**
     * 多线程的任务处理方法
     */
    @Override
    public void run() {
        //System.out.println("MyThread 执行了任务方法run");
        for (int i=1;i<=10;i++){
            //System.out.println("MyThread 执行了任务:"+i);
            //Thread.currentThread().getName():通过线程类获取当前线程对象，获取线程名字
            //   如果线程名字自己没有设置，则用序号表示线程
            System.out.println(Thread.currentThread().getName()+" 执行了任务:"+i);
        }
    }
}

Test：

package com.aaa.test;

/**
 * @author: hy
 * @create: 2022-09-15 11:05:13
 */
public class Test {
    public static void main(String[] args) {
        //创建线程类
        MyThread myThread = new MyThread();
        //自己设置线程名字
        //myThread.setName("Thread-aaa");
        //直接调用线程的run方法，无法实现多线程的执行特征
        //myThread.run();
        //start:可以让线程处于就绪状态，能够被线程调度器进行调度管理，从而实现多线程的运行方式
        myThread.start();
        //start不能调用多次
        //myThread.start();

        //创建第二个线程对象
        MyThread myThread2 = new MyThread();
        myThread2.start();

        //System.out.println("这是main方法的执行过程");
        for (int i=1;i<=10;i++){
            //System.out.println("Main方法执行:"+i);
            System.out.println(Thread.currentThread().getName()+" 方法执行:"+i);
        }
    }
}

②代码结构布局：

在这里插入图片描述

运行结果：

在这里插入图片描述

代码如下：

MyRunnable ：

package com.aaa.test2;

/**
 * 实现多线程编程的第二种方式:定义类实现Runnable接口，用于定义线程要【执行的任务】
 * @author: hy
 * @create: 2022-09-15 11:37:28
 */
public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i=1;i<=10;i++){
            System.out.println(Thread.currentThread().getName()+"执行:"+i);
        }
    }
}

Test ：

package com.aaa.test2;

/**
 * @author: hy
 * @create: 2022-09-15 11:39:53
 */
public class Test {
    public static void main(String[] args) {
        //创建多线程要执行的任务实体
        MyRunnable myRunnable =new MyRunnable();

        //创建多线程对象，来执行目标任务
        Thread t1 = new Thread(myRunnable);
        t1.start();

        Thread t2 = new Thread(myRunnable);
        t2.start();


        for (int i=1;i<=10;i++){
            System.out.println(Thread.currentThread().getName()+"执行"+i);
        }
    }
}

③代码结构布局：

在这里插入图片描述

运行结果：

在这里插入图片描述

代码如下：

SumCallable ：

package com.aaa.test3;
//JUC
import java.util.concurrent.Callable;

/**
 * 实现多线程编程方式三:实现Callable定义线程任务。可以实现分布式计算
 * @author: hy
 * @create: 2022-09-15 11:47:06
 */
public class SumCallable implements Callable {
    int start;
    int end;

    public SumCallable(int start,int end){
        this.start=start;
        this.end=end;
    }

    @Override
    public Object call() throws Exception {
        int sum =0;
        for (int i=start;i<=end;i++){
            sum+=i;
            System.out.println(Thread.currentThread().getName()+"执行"+i);
        }
        return sum;
    }
}

Test：

package com.aaa.test3;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * @author: hy
 * @create: 2022-09-15 11:50:18
 */
public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //求1-100的和,通过Callable方式实现多线程的任务执行，分布运算并合并

        //创建callable任务执行对象
        FutureTask ft1=new FutureTask(new SumCallable(1,49));
        FutureTask ft2=new FutureTask(new SumCallable(50,100));

        //创建线程实体，关联任务对象
        new Thread(ft1).start();
        new Thread(ft2).start();

        //线程执行完成之后，获取执行结果
        int sum1=(int)ft1.get();
        int sum2=(int)ft2.get();

        System.out.println("ft1:"+sum1);
        System.out.println("ft2:"+sum2);
        System.out.println("两个线程求和的结果:"+(sum1+sum2));
    }
}

异常：

①错误: 找不到或无法加载主类 com.aaa.test3.Test

在这里插入图片描述

解决：

删除target目录文件夹，然后运行代码。
在这里插入图片描述

线程池实现多线程？？？—代码：

MyRunnable ：

package com.aaa.test4;

/**
 * 定义线程任务
 */
public class MyRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+" 执行任务");
    }
}

Test ：

package com.aaa.test4;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Test {
    public static void main(String[] args) {
        //创建线程任务对象
        MyRunnable runnable = new MyRunnable();

        //创建具有固定线程数的线程池
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        //通过线程池执行线程任务:自动会使用线程池中的某个线程来执行任务
        executorService.execute(runnable);
        executorService.execute(runnable);
        executorService.execute(runnable);
        executorService.execute(runnable);
        executorService.execute(runnable);
        executorService.execute(runnable);
        executorService.execute(runnable);
        executorService.execute(runnable);
        executorService.execute(runnable);
        //关闭线程池
        executorService.shutdown();
    }
}

运行结果：

在这里插入图片描述

卖票线程—代码：

代码如下：

SalesTicketThread ：

package com.aaa.test5;

/**
 * 卖票线程
 */
public class SalesTicketThread extends Thread{
    //售票员
    private String saler;
    //票数20
    private int ticket =20;

    //构造方法
    public SalesTicketThread(String saler){
        this.saler=saler;
    }

    /**
     * 实现卖票任务
     */
    @Override
    public void run() {
        //票数大于0，就继续卖票
        while (ticket>0){
            System.out.println(this.saler+"卖票一张，还剩:"+(--this.ticket)+"张");
        }
    }
}

Test ：

package com.aaa.test5;

public class Test {
    public static void main(String[] args) {
        new SalesTicketThread("张三").start();
        new SalesTicketThread("李四").start();
        new SalesTicketThread("王五").start();
    }
}

运行结果：

在这里插入图片描述
在这里插入图片描述

②代码结构布局：

运行结果：

代码如下：

SaleTiketRunnable ：

package com.aaa.test6;

/**
 * 定义卖票任务类
 */
public class SaleTiketRunnable implements Runnable{
    //定义任务
    private int ticket=20;

    @Override
    public void run() {
        while (this.ticket>0){
            System.out.println(Thread.currentThread().getName()+"卖票一张，还剩"+(--this.ticket)+"张");
        }
    }
}

Test ：

package com.aaa.test6;

public class Test {
    public static void main(String[] args) {
        //创建任务对象
        SaleTiketRunnable saleTiketRunnable = new SaleTiketRunnable();
        //创建线程对象执行任务
        new Thread(salesTicketRunnable,"孙悟空").start();
        new Thread(salesTicketRunnable,"猪八戒").start();
        new Thread(salesTicketRunnable,"沙僧").start();
    }
}

运行结果：

在这里插入图片描述

定义/使用匿名内部类实现线程方法—代码：

IA ：

package com.aaa.test7;

public interface IA {
    void test();
}

Test ：

package com.aaa.test7;

public class Test {
    public static void main(String[] args) {
        //IA ia = new TestACls();
        //ia.test();

        //定义匿名内部类实现接口
        IA ia = new IA() {
            @Override
            public void test() {
                System.out.println("这是匿名内部类实现接口方法");
            }
        };

        ia.test();
    }
}

TestACls :

package com.aaa.test7;

public class TestACls implements IA{
    @Override
    public void test() {
        System.out.println("执行了test方法");
    }
}

TestThread :

package com.aaa.test7;

public class TestThread {
    public static void main(String[] args) {
        //使用匿名内部类实现线程方法
        Thread t1=new Thread("t1"){
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"执行任务....");
            }
        };

        Thread t2=new Thread("t2"){
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"执行任务....");
            }
        };

        Thread t3=new Thread("t3"){
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"执行任务....");
            }
        };

        //设置线程优先级:1-10。不设置优先级时，优先级就是5
        t1.setPriority(Thread.MAX_PRIORITY);
        t2.setPriority(3);
        t3.setPriority(Thread.MIN_PRIORITY);

        t1.start();
        t2.start();
        t3.start();
    }
}

运行结果：

在这里插入图片描述
在这里插入图片描述

线程礼让—代码：

Test ：

package com.aaa.test8;

public class Test {
    public static void main(String[] args) {
        //线程礼让
        Thread t1=new Thread("t1"){
            @Override
            public void run() {
                for (int i=1;i<=10;i++){
                    System.out.println(Thread.currentThread().getName()+"执行了:"+i);
                    if(i==5){
                        //线程礼让：当前线程退出执行状态，重新参与时间片的争夺
                        Thread.yield();
                    }
                }
            }
        };

        Thread t2=new Thread("t2"){
            @Override
            public void run() {
                for (int i=1;i<=10;i++){
                    System.out.println(Thread.currentThread().getName()+"执行了:"+i);
                    if(i==5){
                        //线程礼让：当前线程退出执行状态，重新参与时间片的争夺
                        Thread.yield();
                    }
                }
            }
        };

        Thread t3=new Thread("t3"){
            @Override
            public void run() {
                for (int i=1;i<=10;i++){
                    System.out.println(Thread.currentThread().getName()+"执行了:"+i);
                    if(i==5){
                        //线程礼让：当前线程退出执行状态，重新参与时间片的争夺
                        Thread.yield();
                    }
                }
            }
        };

        t1.start();
        t2.start();
        t3.start();
    }
}

运行结果：

在这里插入图片描述

创建Ping工具类，用于测试当前机器到目标主机的连通性—代码：

PingIPRunnable ：

package com.aaa.test9;

import java.io.IOException;

/**
 * 创建ping ip人物类
 */
public class PingIPRunnable implements Runnable{
    private long start;
    private String ip;
    public PingIPRunnable(long start, String ip){
        this.start=start;
        this.ip=ip;
    }

    @Override
    public void run() {
        try {
            PingUtil.ping(ip);
            long end = System.currentTimeMillis();
            System.out.println(Thread.currentThread().getName()+"花费时间:"+(end-start)/1000);

        } catch (IOException e) {
            e.printStackTrace();
        }
    }


}

PingUtil ：

package com.aaa.test9;

import java.io.*;

/**
 * 创建Ping工具类，用于测试当前机器到目标主机的连通性
 */
public class PingUtil {
    /**
     * ping目标主机，判断是否通畅
     * @param ip
     */
    public static void ping(String ip) throws IOException {
        //获取程序运行时工具类
        Runtime runtime = Runtime.getRuntime();
        //执行ping命令，返回ping的执行程序对象
        Process exec = runtime.exec("ping " + ip);
        //执行ping操作，获取ping操作返回的输入流
        InputStream inputStream = exec.getInputStream();
        //构建缓冲输入流，对于ping的结果字符串内容
        //字节字符转换流
        InputStreamReader isr = new InputStreamReader(inputStream,"GBK");
        //构建缓冲字符流
        BufferedReader br =new BufferedReader(isr);
        String str=null;
        boolean isPingSuc=false;
        while((str=br.readLine())!=null){
            //System.out.println(str);
            //如果返回结果包含TTL关键字，则认为ping通了
            if(str.contains("TTL")){
                isPingSuc=true;
                break;
            }
        }

        if(isPingSuc){
            System.out.println("ping "+ip+" 能够ping通");
        }else{
            System.out.println("ping "+ip+" 不能ping通");
        }

        br.close();
        isr.close();
        inputStream.close();
    }
}

Test ：

package com.aaa.test9;

import java.io.IOException;

public class Test {
    public static void main(String[] args) throws IOException {
        //记录开始时间
        long start = System.currentTimeMillis();
        //ping 100-120之间的ip
        for (int i=100;i<=120;i++){
            PingUtil.ping("192.168.0."+i);
        }

        //记录结束时间
        long end = System.currentTimeMillis();
        System.out.println((end-start)/1000+"s");
    }
}

Test2 ：

package com.aaa.test9;

public class Test2 {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();

        //多线程方式，ping ip
        for (int i=100;i<=120;i++){
            new Thread(new PingIPRunnable(start,"192.168.0."+i)).start();
        }

        //long end = System.currentTimeMillis();
        //System.out.println("main:"+(end-start)/1000);

        //扩展:使用线程池的方式，实现ping ip的效果
    }
}

运行结果：

在这里插入图片描述
在这里插入图片描述

同步代码块，对目标代码块加锁;定义同步方法，实现静态方法加锁—代码：

MyRunnable ：

package com.aaa.test10;

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i=1;i<=10;i++){
            show(i);
            //synchronized:同步代码块，对目标代码块加锁
//            synchronized (this) {
//                System.out.println(Thread.currentThread().getName()+ " "+i + " -AAAA-");
//                System.out.println(Thread.currentThread().getName()+ " "+i + "-BBBB-");
//                System.out.println(Thread.currentThread().getName()+ " "+i + "-CCCC-");
//            }
        }
    }

    //synchronized:定义同步方法，实现静态方法加锁
    public static synchronized void show(int i){
        System.out.println(Thread.currentThread().getName()+ " "+i + " -AAAA-");
        System.out.println(Thread.currentThread().getName()+ " "+i + "-BBBB-");
        System.out.println(Thread.currentThread().getName()+ " "+i + "-CCCC-");
    }

    //synchronized:定义同步方法，实现实例方法加锁
//    public synchronized void show(int i){
//        System.out.println(Thread.currentThread().getName()+ " "+i + " -AAAA-");
//        System.out.println(Thread.currentThread().getName()+ " "+i + "-BBBB-");
//        System.out.println(Thread.currentThread().getName()+ " "+i + "-CCCC-");
//    }
}

Test ：

package com.aaa.test10;

public class Test {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        //创建3个线程执行任务
        new Thread(myRunnable).start();
        new Thread(myRunnable).start();
        new Thread(myRunnable).start();
    }
}

运行结果:

在这里插入图片描述

小丫头爱打盹
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
第六章-事务，定时任务
LeicyII的博客
09-14 763
事务、定时任务
Java开发笔记（九十九）定时器与定时任务
pinlantu的博客
05-15 442
前面介绍了线程的几种运行方式，不管哪种方式，一旦调用了线程实例的start方法，都会立即启动线程的事务处理。然而某些业务场景在事务执行时间方面有特殊需求，例如期望延迟若干时间之后才开始事务运行，又如期望每隔若干时间依次启动事务处理，如此种种都要求在指定的时间才能启动线程任务，也就是俗称的定时功能。 有别于一般的线程，Java为定时功能设计了专门的定时任务TimerTask，以及定时器Timer。其...
spring的Task定时任务与事务
weixin_47514459的博客
09-14 3534
SpringTask定时任务 xml方式 1,加载Sring核心依赖（pom.xml配置） 2，添加配置文件，添加IOC扫描器 3，定义定时任务 4，加载定时器下xml配置 6,现象证明 注解方式 定时方法 xml配置 Cron表达式 Spring事务 事务的四大特性(ACID) 原子性(Atomicity) 隔离性(lsolation 四个隔离级别) 持久性(Durability) Spring的事务
定时任务处理
蜗牛不怕慢的博客
08-30 369
实现定时任务的几种方式： （1）java.util.Timer      这个类可以通过调度一个java.util.TimerTask任务，使程序按照某一个频度执行，但不能指定时间执行。 （2）quartz      是一个功能比较强大的的调度器，目前大部分项目采用该方式。 （3）Spring-task      相当于一个轻量级的Quartz，使用较简单，支持注解和配置文件两种形式。
springboot实现定时任务,异步操作,统一结果返回,全局异常处理,拦截器及事务处理
AlbenXie的博客
08-26 1640
本文都是springboot的常用和实用功能,话不多说开始吧 定时任务 1.启动类开启注解 @EnableScheduling //开启基于注解的定时任务 @MapperScan("com.pdzx.dao") @SpringBootApplication public class VideoApplication { public static void main(String[] args) { SpringApplication.run(VideoApplicatio
定时任务处理过程中的问题
anyin6887的博客
06-30 277
前段时间做了业务系统定时任务的一个需求，其中遇到几个问题，有必要思考并沉淀下来，分享出来。 业务系统的定时任务：指的是针对业务系统，每隔指定的一段时间，就做一次任务。那么，这个通知由谁来发？ （1）可以由业务系统自己来指定，利用多线程，指定时间执行一次就OK。但是这样带来的问题是，随着定时任务的越来越多，线程也会越来越多，而且这些线程须一直运行着，无疑对业务系统是一种庞大的负担。同时...
springBoot 添加定时器和事务
热门推荐
sinat_34338162的博客
10-31 1万+
定时器使用 一、启动类上添加注解 二、在配置文件中加上规则（cron的表达式自行百度） 三、在service层中添加任务使用注解： @Scheduled(cron = "${krystal.quarz.order.cron}") 事务使用： 一、pom.xml中添加依赖 &lt;dependencies&gt; &lt;dependency&gt; &lt;!--添...
添加定时任务
weixin_46258873的博客
05-13 295
22
定时处理事务（Spring Task）
baiwangyou的博客
05-05 500
*** 自定义定时任务类*/@Component@Slf4j/*** 定时任务 每隔5秒触发一次*/")log.info("定时任务开始执行：{}",new Date());
关于定时器实现自动整理数据的功能，加事物，效率可以提高100倍左右
xiaofengwwanwwan的博客
09-29 254
/**  *   * 类名称：TimerTask     * 类描述：定时器任务  * 创建人：fsf  * 创建时间：Aug 29, 2017 10:56:27 AM        * @version  V1.0  *  */ @Component public class TimerTask {     @Autowired     private QuanJuBiaoDao quanJuB...
spring中配置定时触发的事务
shaokun305的专栏
01-15 2504
spring中配置定时触发的事务使用Quartz调度器配置:         class="org.springframework.scheduling.quartz.JobDetailBean">          cn.test.EmailReportJob                                     class="org.springframework
Seata与Lcn的区别
jmysql的博客
05-12 966
已成功起飞！将自己进大厂前花4w买的java全套教程，整整300集，现在拿出来分享给大家！拿走不谢！从入门到精通 学会即可就业！_哔哩哔哩_bilibili 相同点 a、都能解决分布式事务问题 b、都使用AOP代理事务 c、事务的提交和回滚都是由发起方决定。 不同点 核心：事务的回滚机制不一致，LCN是全局假关闭事务，Seata是采用undo_log生成逆向sql回滚操作。 a、LCN的事务代理是全局的，采用了假关闭模式。 Seata事务代理只是代理局部各自的事务，在原生sql的前后记录了操作
第九章 spring 事务和定时任务
目小温的博客
09-15 577
0915
service 执行定时任务
sjh_389510506的博客
08-07 2325
app 开启定时任务 1.普通service + 定时任务 可以在界面开启一个service，在结合timer 、TimerTask 完成，比如 Timer timer = new Timer(); TimerTask task = new TimerTask() { @Override public void run() ...
Spring sqlserver job定时操作事务
会飞的程序猿的博客
04-24 777
spring job定时添加public void addUser(){  String sql ="INSERT INTO t_user (username,passwordlogintype) values('admin','admin','1')"  busiApplyDao.executeSql(sql); }第一步 添加 addUser这个bean&lt;!-- 使用MethodInvo...
5分钟搞定，实现 定时任务 的五种方案！
m0_71777195的博客
12-12 2266
我们在实际开发中，多多少少都会用到定时任务来处理一些问题。比如金融项目中的对账，每天定时对昨天的账务进行核对，每个月初对上个月的账务进行核对等。还比如，我们需要处理一些老数据迁移，修复一些新项目和老项目数据不兼容的问题等等。学习资料的：0 基础 Java 自学之路（配套教程）方案1：Timer这个目前在项目中用得较少，直接贴demo代码。具体的介绍可以查看api ，但是在某些框架中是有用到。 执行结果： 这么使用，阿里代码检查插件会提示：从提示中可以看出，在多线程并行处理定时任务时，Timer运行多
jpa在定时任务中执行失败-TransactionRequiredException
清茶的博客
01-29 996
jpa在定时任务中执行失败问题排查与解决
任务调度框架-如何实现定时任务+RabbitMQ事务+手动ACK
最新发布
Sky_MaoXiaoqi的博客
10-16 1712
任务调度框架-如何实现定时任务+RabbitMQ事务+手动ACK
spring boot 系列之八：SpringBoot处理定时任务
JAVA开发老菜鸟的专栏
09-07 248
项目经常会用到定时任务，springboot自然是可以通过整合相关组件来实现的。 目前常用的定时任务的实现有两种： 通过spring 自带的定时器任务@Schedule来实现 通过Quartz来实现 本次借用上一篇《spring boot 整合Mybatis》的既有项目结构进行案例调试。 一、cron表达式 无论上面说的哪种实现方式，都需要用到cron表达式，因此不得不先介绍下它。 Cron...
定时器执行事务会发生多线程冲突吗
08-10
定时器通常会采用多线程的方式来执行定时任务，因此在执行事务时也可能存在多线程冲突的风险。 可能的冲突场景包括： 1. 同一时间点有多个定时器任务需要执行，可能导致多个线程同时对共享资源进行操作，发生冲突。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值