通过Callable接口实现多线程的代码实践

最新推荐文章于 2022-01-11 10:06:04 发布
最新推荐文章于 2022-01-11 10:06:04 发布
阅读量348 收藏
点赞数 1
分类专栏： # 并发编程 文章标签： 并发编程 ExecutorService  线程池
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36154832/article/details/89394156
版权 
package com.way.multithreading;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.Callable;

import javax.annotation.Resource;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

import com.way.context.status2.SayHello;

/**  
  * ClassName: MyCallable <br/>  
  * date: 2019年4月17日 下午3:03:19 <br/>  
  *  
  * @author lixiaolong  
  * @version   
  * @since JDK 1.6  
  */
@Component
@Scope
public class MyCallable implements Callable<Object>{

	private static Logger log = LoggerFactory.getLogger(SayHello.class);
	
	@Resource
	ApplicationContext context;
	
	private String className;
	private Class<?> targetClass;
	private Object targetObject;
	private String methodName;
	private Object[] args;
	
	public void setInitParas(Object targetObject,String methodName,Object[] args){
		this.targetObject = targetObject;
		this.targetClass = targetObject.getClass();
		this.className = targetObject.getClass().getSimpleName();
		this.args = args;
		this.methodName = methodName;
	}
	
	@Override
	public Object call() throws Exception {
		return ReflectUtil.invokeMethod(targetObject, methodName, args);
	}

	public Object getTargetObject() {
		return targetObject;
	}

	public void setTargetObject(Object targetObject) {
		this.targetObject = targetObject;
	}

	public String getMethodName() {
		return methodName;
	}

	public void setMethodName(String methodName) {
		this.methodName = methodName;
	}

	public Object[] getArgs() {
		return args;
	}

	public void setArgs(Object[] args) {
		this.args = args;
	}

	public String getClassName() {
		return className;
	}

	public void setClassName(String className) {
		this.className = className;
	}

	public Class<?> getTargetClass() {
		return targetClass;
	}

	public void setTargetClass(Class<?> targetClass) {
		this.targetClass = targetClass;
	}

}
  

package com.way.multithreading;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class ReflectUtil {
	
	private static Logger log = LoggerFactory.getLogger(ThreadPool.class);

	public static Object invokeMethod(Object targetObject,String methodName,Object[] args){
		Method method = getMethod(targetObject, methodName, args);
		Object objRes = null;
		try {
			objRes = method.invoke(targetObject, args);
		} catch (Exception e) {
			log.error("invokeMethod执行失败！");;
		}
		return objRes;
	}
	
	/**
	  * 
	  * getMethod:根据方法名参数返回方法. <br/>  
	  *  
	  * @return
	  * @throws ClassNotFoundException  
	  * @since JDK 1.6
	  */
	public static Method getMethod(Object targetObject,String methodName,Object[] args) {
		Method[] Methods = targetObject.getClass().getMethods();
		int argsLen = 0;
		if(args!=null){
			argsLen = args.length;
		}
		for (Method method : Methods) {
			//比较方法名
			String name = method.getName();
			if(!name.equals(methodName)){
				continue;
			}
			//比较参数长度
			int len = method.getParameterCount();
			if(len!=argsLen){
				continue;
			}
			//参数都没有直接匹配完成
			if(len==0 && argsLen==0){
				return method;
			}
			
			//剩下都是都有参数的
			boolean matchedResult = true;
			Class<?>[] classTypes = method.getParameterTypes();
			//循环比较每一个参数
			for(int i =0;i<argsLen;i++){
				Class<? extends Object> targetClass = classTypes[i];
				Class<? extends Object> myClass = args[i].getClass();
				//不一样结束循环
				if(!compareTo(myClass, targetClass)){
					matchedResult = false;
					break;
				}
			}
			//比较都一致返回方法
			if(matchedResult){
				return method;
			}
		}
		return null;
	}
	
	/**
	  * 
	  * compareTo:按级别规则比较
	  *  
	  * @return  
	  * @since JDK 1.6
	  */
	private static boolean compareTo(Class<? extends Object> originClass,Class<? extends Object> targetClass){
		int originInt = transToForCompare(originClass);
		int targetInt = transToForCompare(targetClass);
		//至少一个是-1，就比较是否一样
		if( originInt < 0 || targetInt < 0 ){
			if( originInt == targetInt){
				return true;
			}else{
				return false;
			}
		}
		
		//至少一个为0，就比较类是否一样
		if( originInt == 0 || targetInt == 0 ){
			if(originClass.isAssignableFrom(targetClass)){
				return true;
			}else{
				return false;
			}
		}
		
		//其他情况比较参数级别，参数级别高于函数的类型可以自动转换，否则结果不符合
		if(originInt>=targetInt){
			return true;
		}else{
			return false;
		}
	}
	
	/**
	  * 
	  * transToForCompare:数据类型分级用于比较. <br/> 
	  * 根据非赋值运算数据类型自动 转换规则byte/char/short -> int ->  long -> float -> double
	  * 把数据类型分级分别是5-1，boolean为-1，其他类型为0
	  * @return  
	  * @since JDK 1.6
	  */
	private static Integer transToForCompare(Class<? extends Object> clazz){
		String className = clazz.getName();
		List<String> strLst0 = new ArrayList<>(Arrays.asList("boolean","java.lang.Boolean"));
		if(strLst0.contains(className)){
			return -1;
		}
		List<String> strLst1 = new ArrayList<>(Arrays.asList("byte","char","short","java.lang.Byte","java.lang.Short","java.lang.Character"));
		if(strLst1.contains(className)){
			return 5;
		}
		List<String> strLst2 = new ArrayList<>(Arrays.asList("int","java.lang.Integer"));
		if(strLst2.contains(className)){
			return 4;
		}
		List<String> strLst3 = new ArrayList<>(Arrays.asList("long","java.lang.Long"));
		if(strLst3.contains(className)){
			return 3;
		}
		List<String> strLst4 = new ArrayList<>(Arrays.asList("float","java.lang.Float"));
		if(strLst4.contains(className)){
			return 2;
		}
		List<String> strLst5 = new ArrayList<>(Arrays.asList("double","java.lang.Double"));
		if(strLst5.contains(className)){
			return 1;
		}
		return 0;
	}
}
  

package com.way.multithreading;

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

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;


public class ThreadPool {

	private static Logger log = LoggerFactory.getLogger(ThreadPool.class);
	
	private static ExecutorService threadPool = null;
	public synchronized static ExecutorService getInstance(){
		if(threadPool==null){
			threadPool = Executors.newFixedThreadPool(200);
		}
		log.info("线程创建成功");
		return threadPool;
	}

}

测试类

package com.way.spring.Docbus;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.ApplicationContext;
import org.springframework.test.context.junit4.SpringRunner;

import com.way.context.status2.SayHello;
import com.way.multithreading.MyCallable;
import com.way.multithreading.ThreadPool;

@RunWith(SpringRunner.class)
@SpringBootTest
public class Test2 {

	private static Logger log = LoggerFactory.getLogger(Test2.class);
	
	@Autowired
	ApplicationContext applicationContext;
	@Autowired
	MyCallable bean;
	@Autowired
	SayHello sayHello;
	
	@Test
	public void test() throws Exception {
		ExecutorService threadPool = ThreadPool.getInstance();
		
		Object[] obj ={false};
		Object[] obj1 ={1.1,3L};
		Object[] obj2 ={1};
		Object[] obj3 ={"polo"};
		List<Object[]> list = new ArrayList<>(Arrays.asList(obj,obj1,obj2,obj3));
		
		for (Object[] objects : list) {
			bean.setInitParas(sayHello, "test", objects);
			Future<Object> res = threadPool.submit(bean);
			log.info("res = "+res.get());
		}
	}
}

运行结果：

钦拆大仁
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程Callable接口实现代码示例
08-29
相信大家对Java编程中如何创建线程已经不陌生了，这篇文章就向朋友们介绍实现callable接口，具体实例详见正文。
通过Callable实现多线程
kongshuchen的博客
06-04 3432
在java.util.concurrent包下，相比较于通过实现Runnable接口的run方法来实现多线程，优点在于可以有返回值，可以抛出异常，因为run方法是void的，并且不能抛出异常，但是Callable的方式缺点在于较为繁琐。 Callable的任务执行后可返回值，运行Callable任务可以拿到一个Future对象。Future表示异步计算的结果。它提供了检查计算是否完成的方法，以等待
通过Callable接口实现多线程
evilcry2012的专栏
10-25 583
通过Callable接口实现多线程 2016-05-26 12:35 460人阅读 评论(0) 收藏 举报  分类： J2SE（38）  版权声明：本文为博主原创文章，未经博主允许不得转载。 之前通过继承Thread类实现多线程，通过Runnable接口+静态代理实现多线程 但是有一个不足之处是，重写run方法时没有返回值也不能抛出异
多线程
caiannan1998的博客
05-14 70
创建线程方式 方式一 package com.annan.demo01; //创建线程方式一:继承Thread类，重写run()方法，调用start开启线程 //总结：线程开启不一定立即执行，由cpu调度 public class TestThread1 extends Thread{ @Override public void run() { //run方法线程体 for (int i = 0; i < 20; i++) {
详解Java Callable接口实现多线程的方式
08-19
主要介绍了详解Java Callable接口实现多线程的方式，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
基于Java Callable接口实现线程代码实例
08-24
主要介绍了基于Java Callable接口实现线程代码实例,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Java多线程实现Callable接口
09-02
本文给大家分享的是使用Java多线程来实现callable接口的方法，以及使用方法，另外还有一个网友的实例，希望能够对大家掌握Java多线程有所帮助。
Java多线程Callable接口
01-20
Runnable是执行工作的独立任务，但是它不返回任何值，如果你希望任务在完成时能够返回一个值，那么可以实现Callable接口而不是Runnable接口。在Java SE5中引入的Callable是一种具有类型参数的泛型，它的类型参数表示...
创建多线程的方式三：实现Callable接口
m0_55895641的博客
01-11 854
实现Callable接口与实现Runnable接口方法差不多，不同之处在于实现Callable接口是重写Call方法，且Call方法是有返回值的。Call方法也可以抛出异常，也支持泛型。 步骤：1.创建实现Callable接口的实现类 2.重现实现类中的Call()方法 3.创建实现类的对象 4.将实现类对象作为参数传入FutureTask构造器中，创建FutureTask对象 5.将FutureTask创建的对象作为参数传入Thread类构造器中创建Thread对象并调用start()方法。
Java总结（十一）——通过Callable接口实现多线程，生产者消费者问题，多线下载（复制）文件...
weixin_34197488的博客
03-17 211
一.通过Callable接口实现多线程1.Callable接口介绍：（1）java.util.concurrent.Callable是一个泛型接口，只有一个call()方法（2）call()方法抛出异常Exception异常，且返回一个指定的泛型类对象2.Callable接口实现多线程的应用场景（1）当父线程想要获取子线程的运行结果时3.使用Callable接口实现多线程的步...
Callable实现多线程
奔跑的蜗牛
05-05 3421
运行下面的代码，我们会发现，I'm T..... 和 I'm T0.....会交替输出。通过下面的代码我们可以知道，这种方式相对于Runnable的实现方式，又更加灵活了，因为它可以将处理结果返回（即call方法是有返回值的）。这里顺便总结一下这种方式和实现Runnable接口的方式的区别： 1、Runnable接口复写的是run方法，而Callable接口复写的是call方法 2、Runn...
利用Callable接口实现多线程
一个被代码耽搁了的法师
05-19 386
优点：可以获取返回值，可以抛出异常 Callable和Future接口 Callable是类似于Runnable的接口，实现Callable接口的类和实现Runnable的类都是可被其它线程执行的任务 Callable和Runnable的不同： （1）Callable规定的方法是call()，而Runnable规定的方法是run()。 （2）call()方...
多线程实战——Callable接口在项目中的实际应用
我就说我500的博客
07-16 1154
1.Callable接口介绍 我们在实现多线程的时候一般都是实现Runnable接口，这种方式简单高效，但缺点也同样明显，就是无法在线程结束后返回相应结果，去过需要返回结果，只能手动在多线程中使用公共变量进行传递，容易发生线程安全问题，所以，现在让我们来看一下可以返回信息的Callable接口的多线程具体使用！ Callable接口定义： public interface Callable<V> { V call() throws Exception; } 观察发现： 与Runnab
Callable接口实现多线程-经验总结
weixin_41860568的博客
11-17 421
业务场景 根据客户集合，循环调用某查询接口，对返回金额做累加。 实现方式 通过Callable接口的方式实现多线程的异步调用； 经验： 任务类Task实现Callable接口，定义相关成员（查询接口入参），重写call()方法实现查询接口调用逻辑； 在循环调用时需注意先定义一个Future集合，循环执行task实例后，将返回的结果对象放入集合；再对结果集合遍历累加；（不可直接在执行任务循环的内部进行累加，会导致仍为同步调用） 线程池可使用ThreadPoolExecutor ...
多线程的几种实现方式(简易版)--Callable接口介绍
weixin_39582009的博客
09-02 470
1.继承Thread类       2.实现Runnable接口       3.使用Callable和Future创建线程:相比于其它2种实现方式,大家可能对此种方式会比较陌生一点;        下面将着重介绍第三种实现多线程的方式:                从JAVA5开始,JAVA提供了Callable接口,该接口怎么看都像是Runnable接口的增强版,Callable接口
java的callable_Java多线程Callable接口实现代码示例
weixin_27076351的博客
02-12 208
对于多线程，大家并不陌生，对于如何创建线程也是轻车熟路，对于使用new thread和实现runable接口的方式，不再多说。这篇博文我们介绍第三种：实现Callable接口。Callable接口接口定义：@FunctionalInterfacepublic interface Callable {V call() throws Exception;}从Callable的定义可以看出：Callab...
详述Java实现Callable接口实现多线程的方式
热门推荐
weixin_42606135的博客
07-30 2万+
公司项目忙的晕头转向，终于有时间可以看点自己想看的东西了。在这里把最近学习的实现Callable接口实现多线程的方式做一个总结： 首先我们都知道，在Java中最常见的是继承Thread类和实现Runnable接口来实现多线程（ 这里我推荐采用实现接口的方式来实现多线程，原因有两点： 1、Java的设计是单继承的设计，如果采用继承Thread的方式实现多线程，则不能继承其他的类。 2、采用接...
实现Callable接口可以创建线程吗
最新发布
05-30
是的，通过实现Callable接口也可以创建线程。在Java中，实现Callable接口是创建线程的另一种方式，相比较于实现Runnable接口，Callable接口可以返回线程的执行结果，同时也可以抛出异常。创建线程的步骤如下： 1. ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值