java线程池创建ThreadPoolTaskExecutor和Executors

一.ThreadPoolTaskExecutor创建方式
1.注入线程池对象五个参数，面试常问

<bean id="taskExcetor"
		class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
		<property name="corePoolSize" value="10" />
		<property name="keepAliveSeconds" value="200" />
		<property name="maxPoolSize" value="20" />
		<property name="queueCapacity" value="20" />
		<property name="rejectedExecutionHandler">
			<bean class="java.util.concurrent.ThreadPoolExecutor$CallerRunsPolicy" />
		</property>
	</bean>

属性字段说明
corePoolSize：线程池维护线程的最少数量
keepAliveSeconds：允许的空闲时间
maxPoolSize：线程池维护线程的最大数量
queueCapacity：缓存队列
rejectedExecutionHandler：对拒绝task的处理策略
2.execute方法执行过程
如果此时线程池中的数量小于corePoolSize，即使线程池中的线程都处于空闲状态，也要创建新的线程来处理被添加的任务。
如果此时线程池中的数量等于 corePoolSize，但是缓冲队列 workQueue未满，那么任务被放入缓冲队列。
如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量小于maxPoolSize，建新的线程来处理被添加的任务。
如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量等于maxPoolSize，那么通过handler所指定的策略来处理此任务。也就是：处理任务的优先级为：核心线程corePoolSize、任务队列workQueue、最大线程 maximumPoolSize，如果三者都满了，使用handler处理被拒绝的任务。
当线程池中的线程数量大于corePoolSize时，如果某线程空闲时间超过keepAliveTime，线程将被终止。这样，线程池可以动态的调整池中的线程数。
3.代码中调用线程池,异步处理日志

	@Autowired
	private ThreadPoolTaskExecutor taskExcetor;
	@GetMapping("test")
	public void test(){
	taskExcetor.execute(new Runnable() {
			@Override
			public void run() {
				RobotVoiceInfoEntity robotVoiceInfo = new RobotVoiceInfoEntity();
				robotVoiceInfo.setCreateTime(new Date());
				robotVoiceInfo.setInset(inset);
				robotVoiceInfo.setRobotName(robotName);
				robotVoiceInfo.setText(text);
				robotVoiceInfoService.save(robotVoiceInfo);
			}
		});
	}

二.Executors创建线程池
1.创建线程池

@Component
public class SocketServer {
	public static Map<String, Socket> map = new ConcurrentHashMap<String, Socket>();
	@PostConstruct
	public void acceptData() {
		new Thread(new Runnable() {
			@Override
			public void run() {
				ExecutorService pool = Executors.newFixedThreadPool(50);
				try(ServerSocket serverSocket = new ServerSocket(Integer.parseInt(port))) {
					while(true) {
						Socket socket = serverSocket.accept();
						String ip = socket.getInetAddress().toString();
						map.put(ip,socket);
						Callable<Void> task = new SocketCallable(socket,ip);
						pool.submit(task);
					}
				}catch(BindException e) {
					e.printStackTrace();
				}catch(IOException e) {
					e.printStackTrace();
				}
			}
		}).start();
	}
}	

2.socket多线程等待客户端链接

	private Logger logger = LoggerFactory.getLogger(this.getClass());
	private Socket socket;
	private String ip;
	public SocketCallable(Socket socket,String ip) {
		this.socket = socket;
		this.ip = ip;
	}
	@Override
	public Void call() {
		try {
			InputStream inputStream = socket.getInputStream();
			DataInputStream dis = new DataInputStream(inputStream);
			OutputStream outputStream = socket.getOutputStream();
			DataOutputStream dos = new DataOutputStream(outputStream);
			while(true) {
				byte[] datas1 = new byte[7];
				dis.readFully(datas1);
				String prefix = Hex2AscUtil.hex2Asc(datas1.length, datas1);
				String hex = prefix.substring(12);
				byte[] datas2 = null;
				if("80".equals(hex)) {
					datas2 = new byte[8];
					dis.readFully(datas2);
					byte[] reqdata = {(byte) 0x57, 0x4b, 0x4c, 0x59, 0x09, 0x00, (byte) 0x80, 0x00, 0x00};
					dos.write(reqdata);
					dos.flush();
					String resp = Hex2AscUtil.hex2Asc(reqdata.length, reqdata);
				}else{
					logger.info("socket解析数据不正确");
					continue;
				}
			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			if(socket != null)
				try {
					Socket remove = SocketServer.map.remove(ip);
					socket.close();
				}catch(IOException e1) {
					e1.printStackTrace();
				}
		}
		return null;
	}
}