java多线程创建线程任务 线程池

最新推荐文章于 2024-04-10 23:56:53 发布
置顶 最新推荐文章于 2024-04-10 23:56:53 发布
阅读量1.5k 收藏
点赞数 2
分类专栏： 多线程 线程池 文章标签： java 多线程 线程池
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rm_rf1024/article/details/117808599
版权

 1、配置文件

gateway.taskjob.maxthread=3  线最线程数
gateway.taskjob.myid=kabalaweb1
gateway.taskjob.timeSeconds=60   定时调用时间

2、任务代码 

package com.kass.gateway;

import java.sql.SQLException;
import java.util.List;
import java.util.Map;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import com.kass.kabala.KDatabase;
import com.kass.kabala.kabalautils.CTimeTools;
import com.kass.kabala.utils.KJsonTools;
import com.kass.kabala.utils.KLog;
import com.kass.kabala.utils.KMapTools;
import com.kass.kabala.utils.KStringTools;
import com.kass.kabala.utils.KTimeTools;

public class TaskJob {
	private static enum JobStatus{
		waiting,
		runing
	}
	public interface MyJob {
		public boolean doing(String tenantid,String taskid) throws Exception;//返回 true 表示成功 false表示失败
		public void ok(String tenantid,String taskid)throws Exception;//任务执行结束
		public void retryFail(String tenantid,String taskid);//任务超出通知
	}
	private static ExecutorService executor = null;//暂时为无序任务，后续如果任务量大的话可以考虑换成队列任务
	public static void init(){
		int maxThread = KStringTools.toInt(System.getProperty("gateway.taskjob.maxthread"),10); 	//最大执行线程
		String myid = System.getProperty("gateway.taskjob.myid");
		if(myid.equalsIgnoreCase(System.getProperty("kabala.myid"))) { //任务服务只允许在一台机器上运行
			executor = Executors.newScheduledThreadPool(maxThread);
			
			//发起一个任务,将状态为等待的加入队列
			Timer timer = new Timer();
			timer.scheduleAtFixedRate(new TimerTask() {
				@Override
				public void run() {
					try {
						String sql = "select tenantid,taskid,status,ctime,retrycount,maxretry,jointime,exectime,execmsg,myjobclass from k_task_job where status = ? ";
						List<Map> datas = KDatabase.queryJSON(sql,new String[] {JobStatus.waiting.name()});
						if(datas==null || datas.size()==0 ) {
							return;
						}
						for(int i = 0;i<datas.size();i++) {
							try {
								String tenantid = KMapTools.getString(datas.get(i),"tenantid");
								String taskid = KMapTools.getString(datas.get(i),"taskid");
								int retrycount = KMapTools.getInt(datas.get(i),"retrycount");
								int maxretry = KMapTools.getInt(datas.get(i),"maxretry");
								String myjobclass = KMapTools.getString(datas.get(i),"myjobclass");
								if(maxretry>0 && retrycount>=maxretry) {
									KLog.info("关闭任务","任务超出最大执行次数",KJsonTools.map2json(datas.get(i)));
									closeJob(tenantid,taskid);
									try {
										MyJob myjob = (MyJob)Class.forName(myjobclass).newInstance();
										myjob.retryFail(tenantid,taskid);
									}catch(Exception e) { 
										KLog.error(e);
									}
								}else {
									KLog.info("任务加入队列",KJsonTools.map2json(datas.get(i)));
									execJob(datas.get(i));
								}
							}catch(Exception e) {//一个任务调度出错，不影响其他的
								KLog.error(e);
							}
						}
					}catch(Exception e) {
						KLog.error(e);
					}
				}
			},1000L, KStringTools.toInt(System.getProperty("gateway.taskjob.timeSeconds"),60)*1000L);
		}
	}
	
	//重置任务为等待状态
	private static void restJob(String tenantid,String taskid,long exectime,String execmsg) throws Exception{
		String sql = "update k_task_job set status = ? , exectime = ? , execmsg = ? where tenantid = ? and taskid = ? ";
		KDatabase.execute(sql,new String[] {
				JobStatus.waiting.name(),
				String.valueOf(exectime),
				execmsg,
				tenantid,
				taskid
		});
		KLog.info("任务状态重置",tenantid,taskid,String.valueOf(exectime),execmsg);
	}
	
	//关闭任务
	private static void closeJob(String tenantid,String taskid) throws Exception{
		String sql = "delete from k_task_job where tenantid = ? and taskid = ?";
		KDatabase.execute(sql,new String[] {tenantid,taskid});
		KLog.info("任务删除",tenantid,taskid);
	}
	
	private static void execJob(final Map jobdatas) throws Exception{
		final String tenantid = KMapTools.getString(jobdatas,"tenantid");
		final String taskid = KMapTools.getString(jobdatas,"taskid");
		final int retrycount = KMapTools.getInt(jobdatas,"retrycount");
		final int maxretry = KMapTools.getInt(jobdatas,"maxretry");
		final String myjobclass = KMapTools.getString(jobdatas,"myjobclass");
		if(maxretry>0 && retrycount>=maxretry) {
			throw new Exception("任务超出最大限制次数");
		}
		//标记任务状态及加入时间
		String sql = "update k_task_job set status = ? , jointime = ? , retrycount=? where tenantid = ? and taskid = ? ";
		KDatabase.execute(sql,new String[] {
				JobStatus.runing.name(),
				String.valueOf(CTimeTools.getTimeNumber(System.currentTimeMillis())),
				String.valueOf( (retrycount+1) ),
				tenantid,
				taskid
		});
		//加入队列
		executor.execute(new Runnable() {
			@Override
			public void run() {
				long exectime = KTimeTools.getTimeNumber(System.currentTimeMillis());
				try {
					KLog.info("任务执行开始",KJsonTools.map2json(jobdatas));
					MyJob myjob = (MyJob)com.kass.kabala.utils.KReflectTools.createInstance(myjobclass);
					if(myjob.doing(tenantid,taskid) ) { //执行成功
						closeJob(tenantid,taskid);
						myjob.ok(tenantid,taskid);//任务释放后进行通知
						KLog.info("任务执行成功",KJsonTools.map2json(jobdatas));
					}else {
						throw new Exception("Doing Fail");
					}
				}catch(Exception e) {
					KLog.error(e);
					KLog.info("任务执行出错",KJsonTools.map2json(jobdatas),e.getMessage());
					try {
						restJob(tenantid,taskid,exectime,e.getMessage());
					} catch (Exception e1) {
						KLog.error(e1);
					}
				}
			}			
		});
	}
	
	
	
	/***
	 * 	添加一条任务
	 * @param tenantid 		租户ID
	 * @param taskid		业务方ID
	 * @param myjobclass	执行任务class的位置，需实现TaskJob.myjob 
	 * @param maxRetry		最大执行次数，0表示不限制次数
	 * @throws Exception
	 */
	public static void addJob(String tenantid,String taskid,String myjobclass,int maxRetry) throws Exception{		
		String sql = "select taskid from k_task_job where taskid = ? ";
		String[][] datas = KDatabase.query(sql,new String[] {taskid});
		if(datas!=null && datas.length>0) {
			return;//之前已存在
		}
		sql = "insert into k_task_job(tenantid,taskid,status,ctime,retrycount,maxretry,myjobclass) values (?,?,?,?,?,?,?)";
		KDatabase.execute(sql,new String[] {
				tenantid,
				taskid,
				JobStatus.waiting.name(),
				String.valueOf(CTimeTools.getTimeNumber(System.currentTimeMillis())),
				String.valueOf(0),
				String.valueOf(maxRetry),		
				myjobclass
		});
	}

}

3、重写方法

@Override
    public boolean doing(String tenantid, String taskid) throws Exception {
        String sql = "select gt.cuserid,gt.taskjson,gtf.cnum,gtf.filename from gateway_task gt\n" +
                     "INNER JOIN gateway_task_files gtf on gtf.taskid = gt.taskid\n" +
                     "where gt.tenantid = ? and gt.taskid = ?\n";
        List<Map> datas = KDatabase.queryJSON(sql, new String[]{tenantid,taskid});
        Boolean boo = null;
        try {
            //敏感词统计
            boo = Task.setSensitiveCount(KMapTools.getString(datas.get(0), "cuserid"), KMapTools.getLong(datas.get(0), "cnum"), KMapTools.getString(datas.get(0), "filename"));
            if (boo) {
                return boo;
            } else {
                return false;
            }
        } catch (Exception e) {
            sql = "update gateway_task set taskstatus=? where tenantid = ? and taskid = ?";
            KDatabase.execute(sql, new String[]{Task.TaskStatus_ReadingFile, tenantid, taskid});
            KLog.info("敏感词统计失败:" + KMapTools.getString(datas.get(0), "filename") + e);
            KLog.error(e);
            return false;
        }
    }

    @Override
    public void ok(String tenantid, String taskid) throws Exception {
        String sql = "select gt.cuserid,gt.taskjson,gtf.cnum,gtf.filename from gateway_task gt\n" +
                     "INNER JOIN gateway_task_files gtf on gtf.taskid = gt.taskid\n" +
                     "where gt.tenantid = ? and gt.taskid = ?\n";
        try {
            List<Map> datas = KDatabase.queryJSON(sql, new String[]{tenantid,taskid});
            //触发审批流
            Task.sendFolws(tenantid, KMapTools.getString(datas.get(0), "cuserid"), KMapTools.getString(datas.get(0), "taskjson"), taskid);
        } catch (Exception e) {
            KLog.info("审批流触发失败:" + taskid + e.getMessage());
            sql = "update gateway_task set taskstatus=? where tenantid = ? and taskid = ?";
            KDatabase.execute(sql, new String[]{Task.TaskStatus_ReadingFile, tenantid, taskid});
        }
    }

    @Override
    public void retryFail(String tenantid, String taskid) {
        KLog.info("敏感词统计失败:" +taskid);
        try {
            String sql = "update gateway_task set taskstatus=? where tenantid = ? and taskid = ?";
            KDatabase.execute(sql, new String[]{Task.TaskStatus_ReadingFile, tenantid, taskid});
        } catch (Exception e) {
            e.printStackTrace();
            KLog.error(e);
        }
    }

4、数据库表

CREATE TABLE `k_task_job` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `tenantid` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL,
  `taskid` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL,
  `status` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL,
  `retrycount` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL,
  `maxretry` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL,
  `myjobclass` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL,
  `execmsg` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL,
  `ctime` bigint(20) DEFAULT NULL,
  `jointime` bigint(20) DEFAULT NULL,
  `exectime` bigint(20) DEFAULT NULL,
  PRIMARY KEY (`id`),
  KEY `idx_k_task_job_1` (`tenantid`),
  KEY `idx_k_task_job_2` (`taskid`),
  KEY `idx_k_task_job_3` (`status`)
) ENGINE=InnoDB AUTO_INCREMENT=297 DEFAULT CHARSET=utf8;

 

rm -rf /*1024
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 5
    评论
专栏目录
往线程池中动态添加任务示例
weixin_30888027的博客
03-15 526
import java.util.concurrent.BlockingQueue; import java.util.concurrent.ExecutorService; import java.util.concurrent.LinkedBlockingQueue; import java.util.concurrent.ThreadPoolExecutor; import ja...
线程池定时任务添加任务以及停止线程
lmfxrj的博客
07-27 628
线程池定时任务添加任务以及停止线程
Java创建线程的5种方式（附代码示例）
qq_45110186的博客
02-14 3530
在Java中，线程（Thread）是程序执行的最小单元，它允许程序在同一时间执行多个任务。Java中的线程可以由Thread类创建，也可以通过实现Runnable接口或Callable接口创建。
循环体中将任务加入到线程池队列踩坑
chenjiashu_csdn的博客
12-19 1379
循环体中将任务加入到线程池队列踩坑 问题描述 设置好 如何改变文本的样式 强调文本 强调文本 加粗文本 加粗文本 标记文本 删除文本 引用文本 H2O is是液体。 210 运算结果是 1024. 插入链接与图片 链接: link. 图片: 带尺寸的图片: 居中的图片: 居中并且带尺寸的图片: 当然，我们为了让用户更加便捷，我们增加了图片拖拽功能。 如何插入一段漂亮的代码片 去博客设置...
任务加入线程池是的生效和启动过程详解
之城的专栏
12-16 2770
前言 很早之前我就写过两篇关于线程池的博客, 但是这两篇博客的认识比较浅陋, 有很多需要订正的地方, 所以我决定新开一篇博客. https://blog.csdn.net/leisurelen/article/details/107872827 https://blog.csdn.net/leisurelen/article/details/107872827 在这里我先简单描述下线程池的工作流程 加入一个Task, 如果没有达到核心线程数, 启动一个新Worker执行这个Task 再加入一个Task
java多线程，对多线程，线程池进行封装，方便使用
05-16
Java多线程是Java编程中的重要概念，它允许程序同时执行多个任务，提高了程序的效率和响应速度。在Java中，我们可以通过实现Runnable接口或继承Thread类来创建线程。然而，直接使用线程可能存在一些问题，如资源管理...
Java多线程+线程池.docx
03-31
Java 多线程和线程池 Java 多线程是指在 Java 编程语言中，一个线程的动态执行过程。这个过程包括线程的创建、执行和销毁三个阶段。在 Java 中，创建线程有多种方式，包括通过实现 Runnable 接口、继承 Thread 类...
java多线程并发executorservice(任务调度)类
09-04
Java多线程并发是编程中一个重要的概念，特别是在高并发应用和服务器端程序设计中。`ExecutorService` 是 Java 并发包 `java.util.concurrent` 中的一个接口，它提供了线程池服务，能够管理和控制线程的执行。而 `...
Java多线程Executors批量执行数据实现限流
05-20
Java多线程实现数据切割批量执行，实现限流操作。 java线程池Executors实现数据批量操作。 批量异步Executors处理数据，实现限流操作，QPS限流。 线程池调用第三方接口限流实现逻辑。 案例适合： 1.批量处理大数据。...
Java中的线程与线程池.pptx
01-20
2. newSingleThreadExecutor：创建一个单线程线程池，所有任务都在一个线程中顺序执行，保证了任务的执行顺序。 3. newFixedThreadPool：创建一个固定大小的线程池，线程数量保持不变，任务排队等待执行。 4. ...
【线程池添加工作线程的流程】
Java程序员廖志伟
07-20 329
在创建时，需要传入一个 Runnable 对象，这个对象就是工作线程需要执行的任务，可以是一个 Runnable 接口的匿名内部类或者 Lambda 表达式。总之，线程池添加工作线程的流程包括：容器和变量的初始化、两个判断、工作线程的创建和添加、状态的设置和任务的启动、线程数的更新以及操作结果的返回。如果线程池已经关闭，那么不再添加新的线程，并直接返回。添加新的工作线程后，需要更新线程池中的线程数。将新添加的工作线程的状态设置为“运行中”，可以使用 Thread 类中的 setState() 方法。
线程池详解
最新发布
2302_79392547的博客
04-10 715
线程池是一种管理和复用线程的技术.它可以在应用程序启动时创建一组线程,并在需要时将任务分配给这些线程来执行.通过维护一定数量的线程,线程池可以减少现成的创建和销毁的开销.
Java线程池原理
天地孤影任我行的博客
04-18 349
线程池判断核心线程池里的线程是否都在执行任务。如果不是，则创建一个新的工作线程来执行任务。如果核心线程池里的线程都在执行任务，则执行第二步。 线程池判断工作队列是否已经满。如果工作队列没有满，则将新提交的任务存储在这个工作队列里进行等待。如果工作队列满了，则执行第三步 线程池判断线程池的线程是否都处于工作状态。如果没有，则创建一个新的工作线程来执行任务。如果已经满了，则交给饱和策略来处理这个任务 饱和策略 AbortPolicy Java线程池默认饱和策略，不执行此任务，直接抛
Java线程创建的五种方式
qq_65501447的博客
12-05 745
一个线程就是一个执行流".每个线程之间都可以按照顺讯执行自己的代码多个线程之间同时执行着多份代码.常用方法如下：1.为什么要有线程?首先,并发编程成为刚需。最根本的原因就是单核CPU的算力遇到了瓶颈，需要多核CPU。而并发编程能够更充分的利用多核CPU的资源。其次，虽然多进程也可以实现并发编程，但是线程比进程更轻量主要体现在以下三个方面：创建线程比创建进程更快销毁线程比销毁进程更快调度线程比调度进程更快。
定时任务加线程池处理任务的几种方式
木仕的博客
02-03 1292
定时任务 + 线程池处理任务的集中方式
Java线程池
weixin_56738054的博客
01-07 2486
线程池，线程池的七个核心参数，一个简单的线程池
【第77题】JAVA高级技术-多线程11（创建线程的5种方式）
热门推荐
小虚竹的专栏
06-06 3万+
创建线程5大招
Java多线程 - Java创建线程的4种方式
你今天真好看呀
02-18 9648
文章目录1. Java创建线程有哪几种方式？1.1 线程创建方法一：继承Thread类创建线程类1.2 线程创建方法二：实现Runnable接口创建线程目标类1.3 优雅创建Runnable线程目标类的两种方式1.4 通过实现Runnable接口的方式创建线程目标类的优缺点1.5 线程创建方法三：使用Callable和FutureTask创建线程1.6 线程创建方法四：通过线程池创建线程2. 线程的 run() 和 start() 有什么区别？3. Runnable 和 Thread 用哪个好？4. Fut
Java多线程编程：线程池实现与解析
此外，标签中还提及了线程、Java、线程池、生产者消费者模型以及线程状态监控，暗示内容可能涉及多线程编程的深入讨论，包括线程的创建方式、状态转换以及并发控制策略。" 线程池是多线程编程中的一种管理机制，它...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

rm -rf /*1024

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值