【多线程】让线程返回值

很多时候,我们使用线程去处理一些业务,并希望得到结果,这时候,我们可以使用Callable。

下面例子,模拟使用线程查询DB得到一个List。

例子

线程,返回一个List数据

package com.nicchagil.study.thread.cnblogs.No02可返回值的线程;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;

public class QueryDataThread implements Callable<List<Map<String, Object>>> {

    private Map<String, Object> param = null;

    public QueryDataThread(Map<String, Object> param) {
        super();
        this.param = param;
    }

    @Override
    public List<Map<String, Object>> call() throws Exception {

        /* 模拟查询DB后得到结果集合 */
        System.out.println("param -> " + param);
        Map<String, Object> map1 = new HashMap<String, Object>();
        map1.put("id", "1001");
        map1.put("name", "nick huang");

        Map<String, Object> map2 = new HashMap<String, Object>();
        map2.put("id", "1002");
        map2.put("name", "darren lin");

        List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
        list.add(map1);
        list.add(map2);

        /* 设置短暂的睡眠以便观察效果 */
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        return list;
    }

}

启动线程,并等待返回结果

package com.nicchagil.study.thread.cnblogs.No02可返回值的线程;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Call {

    public static void main(String[] args) {
        List<Map<String, Object>> list = null;
        try {
            list = query();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        if (list != null && list.size() > 0) {
            for (Map<String, Object> map : list) {
                System.out.println("id : " + map.get("id") + ", name : " + map.get("name"));
            }
        }
    }

    /**
     * 模拟查询的业务方法
     */
    public static List<Map<String, Object>> query() throws InterruptedException, ExecutionException {
        ExecutorService es = Executors.newCachedThreadPool();

        /* 模拟查询参数 */
        Map<String, Object> param = new HashMap<String, Object>();
        param.put("username", "derick");

        Future<List<Map<String, Object>>> future = es.submit(new QueryDataThread(param));
        List<Map<String, Object>> list = null;
        try {
            list = future.get();
        } finally {
            es.shutdown();
        }

        return list;
    }

}

More?

查询用户数据的线程

package com.nicchagil.study.thread.cnblogs.No02可返回值的线程.No002多个查询;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;

public class QueryDataThread implements Callable<List<Map<String, Object>>> {

    private Map<String, Object> param = null;

    public QueryDataThread(Map<String, Object> param) {
        super();
        this.param = param;
    }

    @Override
    public List<Map<String, Object>> call() throws Exception {

        /* 模拟查询DB后得到结果集合 */
        System.out.println("query user param -> " + param);
        Map<String, Object> map1 = new HashMap<String, Object>();
        map1.put("id", "1001");
        map1.put("name", "nick huang");

        Map<String, Object> map2 = new HashMap<String, Object>();
        map2.put("id", "1002");
        map2.put("name", "darren lin");

        List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
        list.add(map1);
        list.add(map2);

        /* 设置短暂的睡眠以便观察效果 */
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        return list;
    }

}

查询地址数据的线程

package com.nicchagil.study.thread.cnblogs.No02可返回值的线程.No002多个查询;

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

public class QueryExtDataThread implements Callable<Map<String, Object>> {

    private Map<String, Object> param = null;

    public QueryExtDataThread(Map<String, Object> param) {
        super();
        this.param = param;
    }

    @Override
    public Map<String, Object> call() throws Exception {

        /* 模拟查询DB后得到结果集合 */
        System.out.println("query address param -> " + param);
        Map<String, Object> map = new HashMap<String, Object>();
        map.put("1001", "hz");
        map.put("1002", "pl");

        /* 设置短暂的睡眠以便观察效果 */
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        return map;
    }

}

并发调用查询用户数据和地址数据的线程,然后合并数据,并返回

package com.nicchagil.study.thread.cnblogs.No02可返回值的线程.No002多个查询;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Call {

    public static void main(String[] args) {
        List<Map<String, Object>> list = null;
        try {
            list = query();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        if (list != null && list.size() > 0) {
            for (Map<String, Object> map : list) {
                System.out.println(map);
            }
        }
    }

    /**
     * 模拟查询的业务方法
     */
    public static List<Map<String, Object>> query() throws InterruptedException, ExecutionException {
        ExecutorService es = Executors.newCachedThreadPool();

        /* 模拟查询参数 */
        Map<String, Object> param = new HashMap<String, Object>();
        param.put("username", "derick");

        Future<List<Map<String, Object>>> userFuture = es.submit(new QueryDataThread(param));
        Future<Map<String, Object>> addressFuture = es.submit(new QueryExtDataThread(param));
        List<Map<String, Object>> userList = null;
        Map<String, Object> addressMap = null;
        try {
            userList = userFuture.get();
            addressMap = addressFuture.get();
        } finally {
            es.shutdown();
        }

        /* 合并业务数据 */
        if (userList != null && userList.size() > 0) {
            for (Map<String, Object> map : userList) {
                map.put("address", addressMap.get(map.get("id")));
            }
        }

        return userList;
    }

}

参考API

Callable<V>

Future<V>

ExecutorService.submit(java.util.concurrent.Callable)

InterruptedException

ExecutionException

时间: 08-17

【多线程】让线程返回值的相关文章

2.Perl 多线程:Threads(线程返回值)

1 use warnings; 2 use strict; 3 use threads; 4 5 sub TEST{ 6 print "Hello, World!\n"; 7 return (qw/1 2 3 4 'a'/); 8 } 9 10 #返回列表方法1 11 my ($t1) = threads->new('TEST'); 12 print $t1->join, "\n"; 13 14 #返回列表方法2 15 # 16 my $t2 = thr

Android平台调用Web Service:线程返回值

接上文 前文中的遗留问题 对于Java多线程的理解,我以前仅仅局限于实现Runnable接口或者继承Thread类,然后重写run()方法,最后start()调用就算完事,但是一旦涉及死锁以及对共享资源的访问和随时监控线程的状态和执行顺序和线程返回值等就不行了. Callable 和 Future 简介 Callable接口代表一段可以调用并返回结果的代码;Future接口表示是执行异步任务时的状态.返回值等信息.所以说Callable用于产生结果,Future用于获取结果. 1. Callab

java 线程返回值,优先级,后台线程 示例代码

ava 线程返回值,休眠,优先级,后台线程  示例代码 package org.rui.thread.basic; import java.util.ArrayList; import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.ExecutorService; import java.util.concurrent.Execu

C#秘密武器之多线程——参数与返回值

概述 线程函数要么没有参数,要么只能有一个object参数,而且均没有返回值,这样就大大降低了程序的灵活性,其实我们想要的是能像普通方法一样正常使用参数和返回值!能不能实现这个需求呢?下面就介绍两种方法 一.添加外壳方法 原理:把参数传递变成了对变量的调用 方法:定义一个专门的线程类. 1.需要向线程传递的参数和返回值作为类的公共属性: 2.线程函数的真正方法也放在该类里边 3.加壳的线程函数也放在里边(真正调用的是2的方法) public class MyThread { public dou

有返回值的多线程demo

package com.jimmy.demo.util; import java.util.HashMap;import java.util.concurrent.*;import java.util.Date;import java.util.List;import java.util.ArrayList; /** * 有返回值的线程 */@SuppressWarnings("unchecked")public class Test { public static void main

java_有返回值线程_提前加载例子

package com.demo.test3; import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.FutureTask; /** * @author QQ: 1236897 * */ //有返回值线程 //提前加载 public class FutureTaskTest { /** * @param args */ pu

python获得线程调用函数的返回值

threading.Thread 并没有显式的提供获取线程调用函数返回值的方法,需求自己实现. 使用数据库是一个办法: 可以让子线程将数据写到数据库中,消费线程再去数据库中读取数据: 如果不想用数据库,可以使用类的全局变量来做传递, 示例代码如下: import os import threading class SubThread(): data = {} def __init__(self): ... def execute_func(self, key): # 执行各种操作 ... ret

Java线程:线程安全类和Callable与Future(有返回值的线程)

一.线程安全类 当一个类已经很好的同步以保护它的数据时,这个类就称为线程安全的.当一个集合是安全的,有两个线程在操作同一个集合对象,当第一个线程查询集合非空后,删除集合中所有元素的时候,第二个线程也来执行与第一个线程相同的操作,也许第一个线程查询后,第二个也查出非空,但是此时明显是不对的.如: 1 public class NameList { 2 private List nameList = Collections.synchronizedList(new LinkedList()); 3

在Java 线程中返回值的用法

http://icgemu.iteye.com/blog/467848 在Java 线程中返回值的用法 博客分类: Java Javathread 有时在执行线程中需要在线程中返回一个值:常规中我们会用Runnable接口和Thread类设置一个变量:在run()中改变变量的值,再用一个get方法取得该值,但是run何时完成是未知的:我们需要一定的机制来保证. 在在Java se5有个Callable接口:我们可以用该接口来完成该功能: 代码如: Java代码   package com.thr