使用线程池与内部类实现方法异步

接口与工具类

• 线程池

package cn.com.wangh.system.config;

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;

/**
 * 
 * @author Administrator
 *
 */
@Component
public class ThreadUtils {

    /**
     * 将线程池注入spring容器
     * 
     * @return
     */
    @Bean
    public ThreadPoolExecutor create() {
        ThreadPoolExecutor pool = new ThreadPoolExecutor(5, 10, 5, TimeUnit.SECONDS,
                new LinkedBlockingQueue<Runnable>());
        return pool;
    }
}

• 接口

package cn.com.wangh.system.user.service;

import java.util.concurrent.Future;

import cn.com.wangh.system.user.bo.User;

/**
 * 
 * @author Administrator
 *
 */
public interface UserService {

    /**
     * 同步创建
     * @param username
     * @param password
     * @return
     */
    User create(String username, String password);

    /**
     * 异步创建
     * @param username
     * @param password
     * @return
     */
    Future<User> asynchCreate(String username, String password);
}

实现类

package cn.com.wangh.system.user.service.impl;

import java.util.concurrent.Callable;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadPoolExecutor;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import cn.com.wangh.system.user.bo.User;
import cn.com.wangh.system.user.service.UserService;
/**
 * 
 * @author Administrator
 *
 */
@Service
public class UserServiceImpl implements UserService {

    /**
     * 引入线程池
     */
    @Autowired
    private ThreadPoolExecutor pool;

    /**
     * 同步创建
     */
    @Override
    public User create(String username, String password) {
        System.out.println("创建成功" + this);
        return new User(username, password);
    }

    /**
     * 异步创建，返回值为一个Future
     */
    @Override
    public Future<User> asynchCreate(String username, String password) {
        // 创建内部类实例
        AsynchCreate asynch = new AsynchCreate(username, password);
        // 内部类实现了Callable接口，可直接放入线程池执行，返回值是一个Future
        return pool.submit(asynch);
    }

    /**
     * 内部类，实现了Callable接口，泛型定义为User
     * @author Administrator
     *
     */
    private class AsynchCreate implements Callable<User> {

        private String username;
        private String password;

        public AsynchCreate(String username, String password) {
            super();
            this.username = username;
            this.password = password;
        }

        /**
         * call()方法类似于Runnable接口的run()方法，但是有泛型返回值，会抛出异常；线程启动时方法被调用
         */
        @Override
        public User call() throws Exception {
            System.out.println(this);
            // 直接调用外部类的同步方法，实现了代码复用
            return create(username, password);
        }
    }
}

上面代码使用spring，外部类是单例，内部类直接调用外部类业务方法，既实现了代码复用，也实现了异步；持有Future返回值后，可随时调用其阻塞方法get()，直至得到泛型结果。