java.util.concurrent线程池使用

java.util.concurrent初始化线程池及多线程的代码


spring配置

 

<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:util="http://www.springframework.org/schema/util"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:task="http://www.springframework.org/schema/task"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
            http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.1.xsd
            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.1.xsd
            http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-4.1.xsd">
  <context:component-scan base-package="com.test.task.task_demo"/>
  
  <bean id="threadPool" class="com.test.task.task_demo.thread.ThreadPool"
		init-method="init">
		<property name="corePoolSize" value="5" />
		<property name="maxPoolSize" value="3000" />
		<property name="keepAliveTime" value="5000" />
	</bean>
</beans>

线程池class

package com.test.task.task_demo.thread;

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


public class ThreadPool {

  private ExecutorService threadPoolExecutor;

  private int corePoolSize;
  private int maxPoolSize;
  private long keepAliveTime;

  public synchronized void init() {
    setThreadPoolExecutor(new ThreadPoolExecutor(corePoolSize, maxPoolSize, keepAliveTime,
        TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>()));
  }

  public ExecutorService getThreadPoolExecutor() {
    return threadPoolExecutor;
  }

  public void setThreadPoolExecutor(ExecutorService threadPoolExecutor) {
    this.threadPoolExecutor = threadPoolExecutor;
  }

  public void setCorePoolSize(int corePoolSize) {
    this.corePoolSize = corePoolSize;
  }

  public void setMaxPoolSize(int maxPoolSize) {
    this.maxPoolSize = maxPoolSize;
  }

  public void setKeepAliveTime(long keepAliveTime) {
    this.keepAliveTime = keepAliveTime;
  }

}

业务类

package com.test.task.task_demo.thread;

public class FutureService implements Runnable {

  private int i;

  public FutureService(int i) {
    super();
    this.i = i;
  }

  @Override
  public void run() {
    System.err.println("i=" + i + "thread=" + Thread.currentThread().getName());
    try {
      Thread.sleep(10);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
  }


}

main方法

package com.test.task.task_demo.thread;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Future;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath*:/applicationContext.xml"})
public class Main {
  
  @Autowired
  private ThreadPool threadPool;
  
  @Test
  public void threadTest() throws IOException{
    List<Future<String>> futures = new ArrayList<Future<String>>();
    for (int i = 0; i < 10; i++) {
      futures.add((Future<String>) threadPool.getThreadPoolExecutor().submit(new FutureService(i)));
    }
    System.in.read();
  }
}

 更多java.util.concurrent的api详解：

http://blog.csdn.net/defonds/article/details/44021605