java Callable使用实例

最新推荐文章于 2021-02-24 10:58:47 发布
最新推荐文章于 2021-02-24 10:58:47 发布
阅读量228 收藏
点赞数
分类专栏： Thread java 文章标签： java 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lan12334321234/article/details/88327827
版权
java 同时被 2 个专栏收录
196 篇文章 0 订阅
订阅专栏
Thread
38 篇文章 0 订阅
订阅专栏
[color=red][size=large]多个线程实现累加[/size][/color] 


package com.thread;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 * @author:xxx
 * @TODO:使用callable进行自增
 */
public class AddCallable {
	public static void main(String[] args) {
		long begin = System.currentTimeMillis();
		ExecutorService threadPool = Executors.newCachedThreadPool();
		AddTask task01 = new AddTask("Task-01", 1, 50);
		AddTask task02 = new AddTask("Task-02", 51, 100);
		//得到的结果集
		Future<Long> resultSet01 = threadPool.submit(task01);
		Future<Long> resultSet02 = threadPool.submit(task02);
		try {
			System.out.println("最后的结果是："+(resultSet01.get()+resultSet02.get()));
		} catch (InterruptedException e) {
			e.printStackTrace();
		} catch (ExecutionException e) {
			e.printStackTrace();
		}
		finally{
			threadPool.shutdown();
		}
		System.out.println(System.currentTimeMillis() - begin);
	}
};

/**
 * @author:xxx
 * @TODO:泛型中的Long表示返回的类型
 */
class AddTask implements Callable<Long> {
	private String name;
	private long begin;
	private long end;

	public AddTask(String name, long begin, long end) {
		this.name = name;
		this.begin = begin;
		this.end = end;
	}

	@Override
	public Long call() throws Exception {
		System.out.println(Thread.currentThread().getName());
		System.out.println(name + " 执行中.......");
		long sum = 0;
		for (long i = begin; i <= end; i++) {
			sum += i;
		}
		return sum;
	}
};


[color=red][size=large]例子 2[/size][/color] 


/**
 * 
 */
package com.comtop.test;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @ProjectName:Skeleton
 * @PackageName:com.comtop.test
 * @Verson :0.1
 * @CreateUser :lanweixing
 * @CreateDate :2014-9-3上午9:41:16
 * @UseFor :
 */
public class DoThread {

	public static void main(String[] args) {
		List<Num> list = new ArrayList<Num>();
		List<Message> result1 = new ArrayList<Message>();
		List<Message> result = new ArrayList<Message>();
		// ExecutorService pool = Executors.newCachedThreadPool() ;
		//使用线程池处理
		ThreadPoolExecutor pool = new ThreadPoolExecutor(3, 4, 3000L,
				TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(2));

		for (int i = 0; i < 1000000; i++) {
			list.add(new Num(i));
		}
		long begin = System.currentTimeMillis();
		try {
			//1000000条数据5个线程跑   每个线程跑集合中的一部分
			for (int i = 0; i < 5; i++) {
				result1 = pool.submit(
						new Main4Thread(list, i * 200000, (i + 1) * 200000))
						.get();
				result.addAll(result1);
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
		} catch (ExecutionException e) {
			e.printStackTrace();
		}
		pool.shutdown();
		System.out.println("所用时间" + (System.currentTimeMillis() - begin));
		System.out.println(result.size());
	}
};

class Main4Thread implements Callable<List<Message>> {
	private List<Num> num;
	private int begin;
	private int end;

	/**
	 * @param num
	 */
	Main4Thread(List<Num> num, int begin, int end) {
		super();
		this.num = num;
		this.begin = begin;
		this.end = end;
	}

	@Override
	public List<Message> call() throws Exception {

		List<Message> msgList = new ArrayList<Message>();
		for (int i = begin; i < end; i++) {
			if (num.get(i).getAge() >= 500000) {
				//线程逻辑处理
				Message msg = new Message();
				msg.setMsg(num.get(i).getAge() + " Too old");
				msgList.add(msg);
			}
		}
		System.out.println(Thread.currentThread().getName());
		return msgList;
	}

};

class Message {
	private String msg;

	public String getMsg() {
		return msg;
	}

	public void setMsg(String msg) {
		this.msg = msg;
	}

};

class Num {
	private int age;

	/**
	 * @param age
	 */
	Num(int age) {
		super();
		this.age = age;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

};


[size=large][color=red]3.使用线程处理项目中的需求[/color][/size]

[color=blue]需求：三个线程并行处理三个SQL语句查询[/color]

[size=small][color=red]线程类[/color][/size] 


@Scope("prototype")
//线程类需要注解到spring中 不然无法使用具体DAO操作
@Service
public class MainExcutor implements Callable<List<XXXVO>> {

	// 日志记录
	private final static Logger logger = LoggerFactory
			.getLogger(MainExcutor.class);
	@Resource
	private XXXDAO xxxDAO;

	private XXXVO xxxVO;

	public XXXVO getXXXVO() {
		return xxxVO;
	}

	public void setXXXVO(XXXVO xxxVO) {
		this.xxxVO = xxxVO;
	}

	MainExcutor() {
		super();
	}

	@Override
	public List<XXXVO> call() throws Exception {
		logger.info(" 线程查询数据中。。。");
		List<XXXVO> resultList = new ArrayList<XXXVO>();
		resultList = this.xxxDAO
				.queryXXXData(xxxVO);
		logger.info(" 线程查询数据结束。。。");
		return resultList;
	}
};


[size=small][color=red]XXXDAO代码片段[/color][/size] 


 //三个线程实例
 @Resource
	private MainExcutor mainExcutor1;

	@Resource
	private MainExcutor mainExcutor2;

	@Resource
	private MainExcutor mainExcutor3;

 Map<String, Callable<List<XXXVO>>> taskMap = new HashMap<String, Callable<List<XXXVO>>>();
		// 三个参数对象各不相同
		BeanCopier beanCopier = BeanCopier.create(XXXVO.class,
				XXXVO.class, false);

		XXXVO xxxVO02 = new XXXVO();
		XXXVO xxxVO03 = new ElectricTopicVO();
		beanCopier.copy(xxxVO, xxxVO02, null);
		beanCopier.copy(xxxVO, xxxVO03 , null);

		// 1   2  3 
		xxxVO.setType("1");
		this.mainExcutor1.setXXXVO(xxxVO);
		taskMap.put("Task1", this.mainExcutor1);

		xxxVO02.setType("2");
		this.mainExcutor2.setXXXVO(xxxVO02);
		taskMap.put("Task2", this.mainExcutor2);

		xxxVO03 .setType("3");
		this.mainExcutor3.setXXXVO(xxxVO03);
		taskMap.put("Task3", this.mainExcutor3);

		MessageThreadPoolExecutor executor = new MessageThreadPoolExecutor(3,
				4, 3000L, TimeUnit.MILLISECONDS,
				new ArrayBlockingQueue<Runnable>(4));
		try {
			Map<String, List<XXXVO>> resultMap = executor
					.performTasks(taskMap);
			for (String key : resultMap.keySet()) {
				tempList = resultMap.get(key);
				resultList.addAll(tempList);
			}
		} catch (InterruptedException e1) {
			e1.printStackTrace();
		}


[size=large][color=blue]线程池实现类（实现并发执行的关键）[/color][/size] 


class MessageThreadPoolExecutor extends ThreadPoolExecutor {

	// 把父类的构造函数全弄出来算了。。。
	public MessageThreadPoolExecutor(int corePoolSize, int maximumPoolSize,
			long keepAliveTime, TimeUnit unit,
			BlockingQueue<Runnable> workQueue, RejectedExecutionHandler handler) {
		super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
				handler);
	}

	public MessageThreadPoolExecutor(int corePoolSize, int maximumPoolSize,
			long keepAliveTime, TimeUnit unit,
			BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory) {
		super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
				threadFactory);
	}

	public MessageThreadPoolExecutor(int corePoolSize, int maximumPoolSize,
			long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
		super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
	}

	public MessageThreadPoolExecutor(int corePoolSize, int maximumPoolSize,
			long keepAliveTime, TimeUnit unit,
			BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory,
			RejectedExecutionHandler handler) {

		super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
				threadFactory, handler);
	}

	// 线程池主要执行方法
	public <T> Map<String, T> performTasks(Map<String, Callable<T>> taskMap)
			throws InterruptedException {
		// 无任务集合
		if (taskMap == null || taskMap.isEmpty()) {
			throw new NullPointerException();
		}
		Map<String, Future<T>> futureMap = new HashMap<String, Future<T>>();
		Map<String, T> messageMap = new HashMap<String, T>();
		boolean done = false;

		try {
			for (String key : taskMap.keySet()) {
				futureMap.put(key, submit(taskMap.get(key)));
			}
			for (String key : futureMap.keySet()) {
				Future<T> f = futureMap.get(key);
				try {
					T result = f.get();
					messageMap.put(key, result);
				} catch (ExecutionException e) {
					System.out.println(e.getMessage());
				}
			}
			done = true;
			return messageMap;
		} finally {
			if (!done) {
				for (String key : futureMap.keySet()) {
					futureMap.get(key).cancel(true);
				}
			}
			this.shutdown();
		}
	}
};


[size=large][color=red]多线程调用多线程[/color][/size][color=blue]需要注意的是子线程的线程池需要调大到大于8否则会导致不同步[/color] 



import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;

public class Test implements Callable<String> {

	private static final MainPoolExecutor executor = new MainPoolExecutor(3,
			4, 3000L, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(
					10));
	private String name;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Test() {
		super();
	}

	public Test(String name) {
		this.name = name;
	}

	@Override
	public String call() throws Exception {
		System.out.println(name + " 开始！");
		Thread.sleep(1000);
		System.out.println(name + " 结束！");
		return null;
	}

	public static void main(String[] args) {

		SuperTest[] testArr = new SuperTest[] { new SuperTest("父线程1"),
				new SuperTest("父线程2"), new SuperTest("父线程3") };
		Map<String, Callable<String>> taskMap = new HashMap<String, Callable<String>>();
		try {
			for (SuperTest test : testArr) {
				taskMap.put(String.valueOf(Math.random()), test);
			}
			executor.performTasks(taskMap);
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			executor.shutdown();
		}
	}
};

class SuperTest implements Callable<String> {
	// 一共有9个线程所以 corePoolSize 和 maximumPoolSize得设置成大于等于9的数字 否则不同步
	private static final MainPoolExecutor executor = new MainPoolExecutor(9,
			9, 3000L, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(
					10));
	private String name;

	public String getName() {
		return name;
	}

	public SuperTest() {
		super();
	}

	public SuperTest(String name) {
		this.name = name;
	}
	@Override
	public String call() {
		Test[] testArr = new Test[] { new Test(name + " 子线程1"),
				new Test(name + " 子线程2"), new Test(name + " 子线程3") };
		Map<String, Callable<String>> taskMap = new HashMap<String, Callable<String>>();
		for (Test test : testArr) {
			taskMap.put(String.valueOf(Math.random()), test);
		}
		try {
			executor.performTasks(taskMap);
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			executor.shutdown();
		}
		return null;
	}
}


[size=large][color=red]FutureTask不会阻塞主线程[/color][/size] 



import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * FutureTask线程执行不会阻塞主线程
 * @author Test
 *
 */
public class NoInterruptTest implements Callable<String> {

	private long longTime;
	// 锁对象 需要放外部 否则
	private final ReadWriteLock lock =new ReentrantReadWriteLock();
	public long getLongTime() {
		return longTime;
	}

	public void setLongTime(long longTime) {
		this.longTime = longTime;
	}

	public NoInterruptTest() {
		super();
	}

	public NoInterruptTest(long longTime) {
		this.longTime = longTime;
	}

	@Override
	public String call() throws Exception {
		// synchronized 用于控制同一个对象的多个线程访问
		lock.writeLock().lock();
		System.out.println(Thread.currentThread().getName()+" 开始！");
		Thread.sleep(longTime);
		System.out.println(Thread.currentThread().getName()+" 结束！");
		lock.writeLock().unlock() ;
		return "lanweixing";
	}
	public static void main(String[] args) throws Exception{
		long n1 = System.currentTimeMillis() ;
		NoInterruptTest callable1 = new NoInterruptTest(3000);
		NoInterruptTest callable2 = new NoInterruptTest(3000);
		ExecutorService executorService = Executors.newCachedThreadPool(); 
		FutureTask<String> task1 = new FutureTask<String>(callable1);
		FutureTask<String> task2 = new FutureTask<String>(callable1);
		executorService.execute(task1);
		executorService.execute(task2);
		while(true)
		{
			if(task1.isDone() && task2.isDone())
			{
				// 获得线程执行结果
				System.out.println(task1.get());
				System.out.println("任务已处理。");
				break ;
			}
		}
		System.out.println((System.currentTimeMillis()-n1)/1000);
		executorService.shutdown();
	}
};
艾伦蓝
关注
专栏目录
Java实现callable_Java Callable接口实现细节详解
weixin_36246453的博客
02-23 652
代码如下import java.util.concurrent.Callable;import java.util.concurrent.ExecutionException;import java.util.concurrent.FutureTask;/*** @author lzq* @data 2020/4/30 0030 - 下午 4:02*/public class Test2 {pub...
java中实现Callable方式创建线程
最新发布
weixin_40323532的博客
06-22 629
1、实现Callable的方式有返回值2、实现Callable的方式可以抛出异常3、实现Callable的方式可以通过FutureTask类中提供了一个cancel方法取消任务。
Java Callable使用
BinGuoLA的博客
07-30 1488
1. 创建线程的三种方式： 继承Thread，重写run方法 实现Runnable接口，重新run方法 实现Callable接口，重写call方法 2. Callable接口实际上是属于Executor框架中的功能类，Callable接口与Runnable接口的功能类似，但提供了比Runnable更加强大的功能。 Callable可以在任务结束的时候提供一个返回值，Runnable无法提供...
java 线程池 callable_Java 线程池的使用实例（包括Runnable和Callable）
weixin_35759015的博客
02-19 356
importjava.util.concurrent.ExecutorService;importjava.util.concurrent.Executors;/***通过Executor接口的四个工厂方法来实现四种线程池。*每一个线程都是通过调用execute(Runnablecommand)方法来执行，该方法接收一个Runnable实例。*@authorZYK**/publi...
Java实现callable_基于Java Callable接口实现线程代码实例
weixin_31755877的博客
02-23 200
实现Callable接口(jdk8新特性)可以获得线程的返回值*前两种方式没有返回值，因为run方法返回void创建一个未来任务类对象 Futrue task = new Future(Callable<>);重写call()方法 　　 可以使用匿名内部类方式task.get()方法获取线程返回结果get方法执行会导致当前方法阻塞 效率较低代码如下import java.util.co...
基于Java Callable接口实现线程代码实例
08-24
基于Java Callable接口实现线程代码实例 Java Callable接口简介 Java Callable接口是Java中的一种特殊接口，用于实现线程的返回值。该接口提供了一个call()方法，该方法可以返回一个值，用于获取线程执行的结果。 ...
Java使用Callable和Future创建线程操作示例
08-25
Java使用Callable和Future创建线程操作示例主要介绍了Java使用Callable和Future创建线程操作，结合实例形式分析了java使用Callable接口和Future类创建线程的相关操作技巧与注意事项。 首先，Java 5开始，Java提供了...
java Callable与Future的详解及实例
08-31
Callable 和 Future 是 Java 多线程编程中的两个关键接口，它们在 Java 5 及以上版本引入，以增强并发处理的能力。Callable 接口类似 Runnable，但提供了更丰富的功能，而 Future 对象则用于管理和控制异步计算的...
Java 线程对比（Thread,Runnable,Callable）实例详解
08-31
在Java中，有三种常见的创建线程的方式：继承Thread类、实现Runnable接口以及使用Callable接口。下面将对这三种方式的使用、优缺点进行详细对比。 1. 继承Thread类 这种方式是最直接的创建线程的方法，通过创建...
JAVA中Callable的使用
03-05
JAVA中Callable的使用。下载后评论可返分
java多线程Future和Callable类示例分享
09-02
JAVA多线程实现方式主要有三种：继承Thread类、实现Runnable接口、使用ExecutorService、Callable、Future实现有返回结果的多线程。其中前两种方式线程执行完后都没有返回值，只有最后一种是带返回值的。今天我们就来研究下Future和Callable的实现方法
java callable实例
streetlight8023的专栏
12-27 544
挺好的一个例子 转载自 http://blog.csdn.net/aboy123/article/details/38307539/ import java.util.concurrent.*; import java.util.Date; import java.util.List; import java.util.ArrayList; /** * 有返回值的线程 */ @
java中callable的使用
mameng1988的博客
03-18 4069
我们知道使用callable可以获得线程中的返回值，下面我们简单介绍callable的使用。 1 创建两个callable的实现类 1.1 BumCallable public class BumCallable implements Callable { @Override public Object call() throws Exception { try {...
Java Callable接口应用举例
热门推荐
Hama White 的博客
03-26 1万+
Runnable是执行工作的独立任务，但是它不返回任何值。在Java SE5中引入的Callable是一种具有类型参数的泛型，它的类型参数表的是从方法call()中返回的值，并且必须使用ExecutorServices.submit()方法调用它，下面是一个简单示例。 package com.test; import java.util.ArrayList; import java.util.
java callable 使用_Java Callable使用
weixin_35997999的博客
02-24 108
package thread.learn;import java.util.concurrent.Callable;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.Future;/*** Created by liujinhon...
Java Callable的用法
QRephen的博客
07-28 1808
Callableb必须使用ExecutorService的submit()方法来进行调用，调用后返回Future对象。Future对象调用get方法是线程阻塞的，所以我们可以用isDone()方法来查询Future是否已经完成。 class MyCallable implements Callable{ MyCallable(){ } @
Java Callable用法
风过云飞去
09-03 408
Callable 和 Runnable 的使用方法大同小异， 区别在于：  1.Callable 使用 call（） 方法， Runnable 使用 run() 方法  2.call() 可以返回值， 而 run()方法不能返回。  3.call() 可以抛出受检查的异常，比如ClassNotFoundException， 而run()不能抛出受检查的异常。  Callable示例
java语言中 Callable使用例子
06-01
下面是一个使用 `Callable` 的 Java 例子： ```java import java.util.ArrayList; import java.util.List; import java.util.concurrent.*; public class CallableExample { public static void main(String[] ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值