package com.fx.test;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
public class TaskExecutionWebServer {
private static final int NTHREADS = 100;
// 使用线程池来避免 为每个请求创建一个线程。
private static final Executor threadPool = Executors.newFixedThreadPool(NTHREADS);
public static void main(String[] args) throws Exception {
ServerSocket server = new ServerSocket(8011);
while (true) {
final Socket socket = server.accept();
threadPool.execute(new Runnable() {
public void run() {
handleRequest(socket);
}
});
}
}
protected static void handleRequest(Socket socket) {
System.out.println(Thread.currentThread().getId());
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
package com.fx.test;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.RejectedExecutionException;
public class LifeCycleWebServer {
private static final int NTHREADS = 100;
private static final ExecutorService exec = Executors.newFixedThreadPool(NTHREADS);
public void start() throws IOException {
ServerSocket server = new ServerSocket(8011);
while (exec.isShutdown()) {
try {
final Socket socket = server.accept();
exec.execute(new Runnable() {
public void run() {
handleRequest(socket);
}
});
} catch (RejectedExecutionException e) {
if (!exec.isShutdown()) {
// log.error(...)
}
}
}
}
protected void handleRequest(Socket socket) {
Request req = readRequest(socket);
if (isShutDown(req)) {
stop();
} else {
dispatchRequest(req);
}
}
public void stop() {
exec.shutdown();
}
// ~ Mock Object And Function..
private static class Request {
}
private Request readRequest(Socket socket) {
// TODO Auto-generated method stub
return null;
}
private boolean isShutDown(Request req) {
// TODO Auto-generated method stub
return false;
}
private void dispatchRequest(Request req) {
// TODO Auto-generated method stub
}
}
package com.fx.test;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.RejectedExecutionException;
public class LifeCycleWebServer {
private static final int NTHREADS = 100;
private static final ExecutorService exec = Executors.newFixedThreadPool(NTHREADS);
public void start() throws IOException {
ServerSocket server = new ServerSocket(8011);
while (exec.isShutdown()) {
try {
final Socket socket = server.accept();
exec.execute(new Runnable() {
public void run() {
handleRequest(socket);
}
});
} catch (RejectedExecutionException e) {
if (!exec.isShutdown()) {
// log.error(...)
}
}
}
}
protected void handleRequest(Socket socket) {
Request req = readRequest(socket);
if (isShutDown(req)) {
stop();
} else {
dispatchRequest(req);
}
}
public void stop() {
exec.shutdown();
}
// ~ Mock Object And Function..
private static class Request {
}
private Request readRequest(Socket socket) {
// TODO Auto-generated method stub
return null;
}
private boolean isShutDown(Request req) {
// TODO Auto-generated method stub
return false;
}
private void dispatchRequest(Request req) {
// TODO Auto-generated method stub
}
}
package com.fx.test;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.RejectedExecutionException;
public class LifeCycleWebServer {
private static final int NTHREADS = 100;
private static final ExecutorService exec = Executors.newFixedThreadPool(NTHREADS);
public void start() throws IOException {
ServerSocket server = new ServerSocket(8011);
while (exec.isShutdown()) {
try {
final Socket socket = server.accept();
exec.execute(new Runnable() {
public void run() {
handleRequest(socket);
}
});
} catch (RejectedExecutionException e) {
if (!exec.isShutdown()) {
// log.error(...)
}
}
}
}
protected void handleRequest(Socket socket) {
Request req = readRequest(socket);
if (isShutDown(req)) {
stop();
} else {
dispatchRequest(req);
}
}
public void stop() {
exec.shutdown();
}
// ~ Mock Object And Function..
private static class Request {
}
private Request readRequest(Socket socket) {
// TODO Auto-generated method stub
return null;
}
private boolean isShutDown(Request req) {
// TODO Auto-generated method stub
return false;
}
private void dispatchRequest(Request req) {
// TODO Auto-generated method stub
}
}
package com.fx.test;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import com.sun.scenario.effect.ImageData;
public class FutureRenderer2 {
private static final int NTHREADS = 100;
private static final ExecutorService exec = Executors.newFixedThreadPool(NTHREADS);
void renderPage(CharSequence source) {
final List<ImageInfo> imageinfos = scanForImageInfo(source);
CompletionService<ImageData> completionService = new ExecutorCompletionService<ImageData>(exec);
for (final ImageInfo imageinfo : imageinfos) {
completionService.submit(new Callable<ImageData>() {
public ImageData call() throws Exception {
// 提高性能点一: 将顺序的下载,变成并发的下载,缩短下载时间
return imageinfo.downloadImage();
}
});
}
renderText(source);
try {
for (int i = 0; i < imageinfos.size(); i++) {
Future<ImageData> f = completionService.take();
// 提高性能点二: 下载完成一张图片后,立刻渲染到页面。
ImageData imagedata = f.get();
reanderImage(imagedata);
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
private void renderText(CharSequence source) {
// TODO Auto-generated method stub
}
private void reanderImage(ImageData data) {
// TODO Auto-generated method stub
}
private List<ImageInfo> scanForImageInfo(CharSequence source) {
// TODO Auto-generated method stub
return null;
}
}
package com.lvyou.fx.test.threadPool;
import java.util.Date;
import java.util.TimerTask;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
/**
* task2
* @author arron
* @date 2015年8月5日 下午2:08:34
* @version 1.0
*/
public class ScheduleTask {
public static void main(String[] args) {
ScheduledExecutorService pool = Executors.newScheduledThreadPool(2);//启用2个线程
Task1 t1 = new Task1();
// 马上运行,任务消耗3秒。运行结束后等待2秒。【有空余线程时】,再次运行该任务
pool.scheduleWithFixedDelay(t1, 0, 2, TimeUnit.SECONDS);
// 马上运行,任务消耗5秒,运行结束后等待2秒。【有空余线程时】,再次运行该任务
Task2 t2 = new Task2();
pool.scheduleWithFixedDelay(t2, 0, 2, TimeUnit.SECONDS);
}
public static class Task1 extends TimerTask{
@Override
public void run() {
System.out.println("----task1 start--------"+new Date().toLocaleString());
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("----5s later, task1 end--------"+new Date().toLocaleString());
}
}
public static class Task2 extends TimerTask{
@Override
public void run() {
System.out.println("----task2 start--------"+new Date().toLocaleString());
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("----5s later, task2 end--------"+new Date().toLocaleString());
}
}
}
package com.lvyou.fx.test.threadPool;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/*
* Executors是线程池框架的一个工具类
*
*/
public class FixedThreadPoolDemo {
public static void main(String[] args) {
ExecutorService pool = Executors.newFixedThreadPool(2);
// 定义一个循环,添加5个任务
for (int i = 0; i < 5; i++) {
int flag = i;
pool.execute(new Runnable() {
// 任务详情:执行6次打印语句。
@Override
public void run() {
for (int j = 0; j < 6; j++) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " " + flag + " " + " `s loop : " + j);
}
}
});
}
pool.shutdown();
}
}
package com.lvyou.fx.test.threadPool;
import java.util.concurrent.Callable;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class FutureDemo {
public static void main(String[] args) {
ExecutorService pool = Executors.newFixedThreadPool(3);
// CompletionService接口内部维护一个结果队列:一堆future....
CompletionService<Integer> cs = new ExecutorCompletionService<>(pool);
for (int i = 1; i < 11; i++) {
final int flag = i * 10;
cs.submit(new Callable<Integer>() {
@Override
public Integer call() throws Exception {
Thread.sleep(1000);
return flag;
}
});
}
for (int i = 0; i < 11; i++) {
try {
System.out.println(cs.take().get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
pool.shutdown();
}
}
分享到:
相关推荐
java 线程池 完整 源码 java 线程池 完整 源码
主要给大家介绍了关于java线程池使用后到底要不要关闭的相关资料,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
Reference: 《创建Java线程池》[1],《Java线程:新特征-线程池》[2], 《Java线程池学习》[3],《线程池ThreadPoolExecutor使用简介》[4],《Java5中的线程池实例讲解》[5],《ThreadPoolExecutor使用和思考》[6] ...
Java线程池使用说明Java线程池使用说明Java线程池使用说明
java线程池知识、
java线程池封装j
简单的线程池程序+中文文档 包结构: com.tangkai.threadpool --SimpleThread.java 工作线程 --TestThreadPool.java 程序入口 --ThreadPoolManager.java 线程池管理类
2.然后根据提示运行java命令执行示例程序,观看线程池的运行结果 目标:Java中多线程技术是一个难点,但是也是一个核心技术。因为Java本身就是一个多线程语言。本人目前在给46班讲授Swing的网络编程--使用Swing来...
基于Java线程池技术实现Knock Knock游戏项目.zip 基于Java线程池技术实现Knock Knock游戏项目.zip 基于Java线程池技术实现Knock Knock游戏项目.zip 基于Java线程池技术实现Knock Knock游戏项目.zip 基于Java线程池...
Java线程池及观察者模式解决多线程意外死亡重启问题,附件含两个要运行代码!
讲述了java线程池的优点,参数,6种线程池的使用场景,线程池用到的handler,线程任务的提交方式等等。
java线程池实例java线程池实例E:\Users\Administrator\workspace
自定义实现Java线程池,学习大师设计思想,瞻仰大神笔法
java线程池的源码分析以及各种池之间的对比;
基于Java线程池技术的数据爬虫设计与实现.pdf
JAVA线程池的原理与实现.pdf
java技术学习——基于Java线程池技术实现Knock Knock游戏项目(包含服务端、客户端两部分) java技术学习——基于Java线程池技术实现Knock Knock游戏项目(包含服务端、客户端两部分) java技术学习——基于Java...
1.媲美java线程池框架,整套源码资源,使用Intellij Idea开发工具,JDK1.8以上 2.带有测试代码 3.可以根据项目实际情况任意调整代码 4.任务队列、拒绝策略 5.BasicThreadPool.java、LinkedRunnableQueue.java、...
java线程池的原理和实现,挺全面的,分享给大家!