`
wuzijingaip
  • 浏览: 329615 次
  • 性别: Icon_minigender_1
  • 来自: 广州
社区版块
存档分类
最新评论

java 线程池

    博客分类：
  • java
 
阅读更多 
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();
	}
}
分享到：
| test
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    java线程池使用后到底要关闭吗

    java线程池使用后到底要关闭吗 java线程池是一种高效的并发编程技术，可以帮助开发者更好地管理线程资源，提高系统的性能和可靠性。然而，在使用java线程池时，一个常见的问题是：使用完线程池后到底要不要关闭？...

    java线程池完整代码

    "Java 线程池完整代码解析" Java 线程池是 Java 语言中的一个重要概念，它允许开发者创建和管理多个线程，以提高程序的并发性和性能。下面是对给定文件的解析，包括 title、description、标签和部分内容的解析。 ...

    java线程池封装j

    Java线程池是一种高效管理线程的技术，它允许开发者预定义一组线程，根据任务的需要灵活调度，而不是每次需要执行任务时都创建新的线程。这种设计模式大大提高了系统的性能，减少了系统资源的消耗，特别是在高并发...

    java线程池知识.ppt

    java线程池知识、

    java线程池实例详细讲解

    Java线程池是一种高效管理线程资源的工具，它能够帮助开发者有效地控制并调度线程，从而提升系统性能，减少系统资源的浪费。在Java中，`ExecutorService`接口是线程池的主要入口，它是`java.util.concurrent`包的一...

    Java线程池使用说明

    Java线程池是Java并发编程中的重要组件，它能够有效地管理和复用线程，从而提高程序的执行效率和降低资源消耗。在JDK 1.5版本之前，Java对线程池的支持非常有限，而在JDK 1.5之后，加入了java.util.concurrent包，...

    java线程池threadpool简单使用源码

    Java线程池（ThreadPool）是Java并发编程中的一个重要概念，它可以帮助我们有效地管理和控制并发执行的任务，从而提高系统的效率和稳定性。线程池通过复用已存在的线程，避免了频繁创建和销毁线程带来的开销，同时也...

    自定义实现Java线程池

    ### 自定义实现Java线程池 #### 一、概述 在深入探讨自定义Java线程池之前，我们先简要回顾一下线程池的基本概念及其重要性。线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动...

    java线程池的源码分析.zip

    Java线程池是Java并发编程中的重要组成部分，它在多线程和高并发场景下扮演着关键角色。本文将深入探讨Java线程池的源码分析，并对比不同类型的线程池，以帮助开发者更好地理解和利用这一强大的工具。 首先，我们要...

    Java 线程池.docx

    Java线程池是一种高效管理线程资源的工具，它的出现是为了应对多线程编程中频繁创建和销毁线程带来的性能开销以及资源消耗。在Java中，通过使用线程池，我们可以预先创建一定数量的线程，这些线程在空闲时可以被复用...

    Java线程池与ThreadPoolExecutor.pdf

    Java线程池是Java并发编程中的重要组成部分，它允许开发者管理多个线程并有效地调度任务。线程池通过ThreadPoolExecutor类实现，这是一个高度可配置的工具，能够根据具体需求定制线程的创建、管理和销毁策略。 ...

    Java简单线程池 线程池中文文档

    简单的线程池程序+中文文档 包结构: com.tangkai.threadpool --SimpleThread.java 工作线程 --TestThreadPool.java 程序入口 --ThreadPoolManager.java 线程池管理类

    Java 线程池的原理与实现

    Java线程池是一种高级的多线程处理框架，它是Java并发编程中非常重要的一个组件。线程池的原理和实现涉及到操作系统调度、内存管理和并发控制等多个方面。理解线程池的工作原理有助于优化程序性能，避免过度创建和...

    一个通用的Java线程池类

    2.然后根据提示运行java命令执行示例程序，观看线程池的运行结果 目标：Java中多线程技术是一个难点，但是也是一个核心技术。因为Java本身就是一个多线程语言。本人目前在给46班讲授Swing的网络编程--使用Swing来...

    java 线程池实现多并发队列后进先出

    Java线程池是一种高效管理并发任务的机制，它允许开发者预先配置一定数量的线程，以便在处理多个并发任务时能有效地复用这些线程，从而避免了频繁创建和销毁线程带来的开销。在Java中，`java.util.concurrent`包下的...

    基于Java线程池技术实现Knock Knock游戏项目.zip

    基于Java线程池技术实现Knock Knock游戏项目.zip 基于Java线程池技术实现Knock Knock游戏项目.zip 基于Java线程池技术实现Knock Knock游戏项目.zip 基于Java线程池技术实现Knock Knock游戏项目.zip 基于Java线程池...

    JAVA线程池的原理与实现.pdf

    Java线程池是一种高效利用系统资源、管理并发执行任务的机制。它的原理是通过预先创建一组线程，这些线程在任务到来时可以立即执行，而不是每次需要执行任务时都新建线程，从而降低了线程创建和销毁带来的开销。...

    Java线程池及观察者模式解决多线程意外死亡重启问题

    Java线程池是Java并发编程中的重要组成部分，它允许开发者高效地管理多个并发执行的线程，有效地控制系统的资源消耗，提高系统性能和稳定性。在Java中，`java.util.concurrent`包提供了`ExecutorService`接口及其...

    Java 线程池.pptx

    讲述了java线程池的优点，参数，6种线程池的使用场景，线程池用到的handler,线程任务的提交方式等等。

Magicbox
Global site tag (gtag.js) - Google Analytics