Java并发编程实战笔记 (第六章--1)

最新推荐文章于 2022-08-02 15:18:10 发布

坐飞机的狗

最新推荐文章于 2022-08-02 15:18:10 发布

阅读量126

点赞数

分类专栏： Java并发编程文章标签： java 多线程

本文链接：https://blog.csdn.net/weixin_39443483/article/details/111567459

版权

Java并发编程专栏收录该内容

20 篇文章 0 订阅

订阅专栏

第六章任务执行

6.1 在线程中执行任务

围绕**“任务执行”来设计应用程序结构时，第一步就是找出清晰的任务边界**。各个任务之间是相互独立的；任务并不依赖于其它任务的状态，结果或者边界效应。独立性有助于实现并发，因为如果存在足够多的处理资源，那么这些独立的任务都可以并行执行。
大多数服务器应用程序都提供了一种自然的任务边界选择方式：以独立的客服请求为边界。

/**
	串行的Web服务器
**/
class SingleThreadWebServer{
	public static void main(String[] args) throws IOException{
		ServerSocket socket = new ServerSOcket(80);
		while(true){
			Socket connection = socket.accept();
			handleRequest(connection);
		}
	}
}

主线程在接受连接与处理相关请求等操作之间不断地交替运行。当服务器正在处理请求时，新到来的连接必须等待直到请求处理完成，然后服务器将再次调用accept，如果处理请求的速度很快并且handleRequest可以立即返回，那么这种方法是可行的。在Web请求的处理中包含了一组不同的运算与I/O操作。服务器必须处理套接字I/O以读取请求和协会响应。此外，服务器还可能处理文件I/O或者数据库请求，这些操作同样会阻塞。如果请求阻塞时间过长，用户将认为服务器是不可用的，因为服务器看似失去了响应。

// 显示地为任务创建线程--通过为每个请求创建一个新的线程来提供服务，从而实现更高的响应性
class ThreadPerTaskWebServer{
	public static void main(String args[]) throws IOException{
		ServerSocket socket = new ServerSocket(80);
		while(true){
			final Socket connection = socket.accept();
			Runnable task = new Runnable(){
				@Override
				public void run(){
					handleRequest(connection);
				}
			};
			new Thread(task).start();
		}
	}
}

优势：

任务处理过程从主线程中分离出来，使得主循环能够更快地重新等待下一个到来的连接。–提高响应性
任务可以并行处理，从而能同时服务多个请求。
任务处理代码必须是线程安全的。

缺陷：

线程生命周期的开销非常高。创建过程，需要JVM和操作系统提供一些辅助操作。
资源消耗。活跃的线程会消耗系统资源，尤其是内存。大量空闲的线程会占用许多内存，给gc带来压力，而且大量线程在竞争CPU资源时还将产生其他的性能开销。
稳定性。在可创造线程的数量上存在一个限制，受JVM的启动参数、Thread构造函数中的请求的栈大小，以及地层操作系统对线程的限制。

在一定的范围内，增加线程可以提高系统的吞吐率，但如果超出了这个范围，再创造更多的线程只会降低程序的执行速度，并且如果过多地创建线程，那么整个应用程序将崩溃。
这种策略：它没有限制可创建线程的数目，只限制了远程用户提交HTTP请求的速度。
因此，某个恶意的用户或者过多的用户，都会使Web服务器的负载达到某个阈值，从而使服务器崩溃。如果服务器需要提供高可用性，并且在高负载情况下能平缓地降低性能。

6.2 Executor框架

使用线程池主要有以下三个原因：
1.创建/销毁线程需要消耗系统资源，线程池可以复用已创建的线程。
2.控制并发的数量。，并发数量过多，可能会导致资源消耗过多，造成服务器崩溃(主要原因)
3.可以对线程做统一管理。

串行执行的问题在于其糟糕的响应性和吞吐量，而“为每个任务分配一个线程”的问题在于资源管理的复杂性。在Java类库中，任务执行的主要抽象不是Thread，而是Executor。

public interface Executor{
	void execute(Runnable command);
}

Executor将任务的提交过程与执行过程解耦合，并用Runnable来表示任务。Executor的实现还提供了对生命周期的支持，以及统计信息收集，应用程序管理机制和性能监视。
Executor基于生产者-消费者模式，提交任务的操作相当于生产者（生成待完成单元），执行任务的线程相当于消费者，如果要在程序中实现一个生产者-消费者的设计，那么最简单的方式就是使用Executor。

class TaskExecutionWebServier{
	private static final int NTHREADS = 100;
	private static final Executor exec = Executors.newFixedThreadPool(NTHREADS);	
	public static void main(String[] args) throws IOException{
		ServerSockets socket = new ServerSocket(80);
		while(true){
			final Socket connection = socket.accept();
			Runnable task = new Runnalbe(){
				public void run(){
					handleRequest(connection);
				}
			};
			exec.execute(task);
		}
	
}

将请求处理任务的提交与任务的实际执行解耦开，并且只需要采用另一种不同的Executor实现，就可以改变服务器行为。
通常，Executor的配准是一次性的，因此在部署阶段就可以完成，而提交任务的代码却会不断地扩散到整个程序中。

执行策略：
通过将任务的提交与执行解耦合，从而无须太大的困难就可以为某种类型的任务指定和修改执行策略。

在什么（what)线程中执行任务？
任务按照什么(what）顺序执行(FIFO、LIFO、优先级)?
有多少个(How many)任务能并发执行？
在队列中有多少个(How many）任务在等待执行?
如果系统由于过载而需要拒绝一个任务，那么应该选择哪一个(which)任务？另外如何(how)通知应用程序有任务被拒绝？
在执行一个**任务之前或之后，**应该进行哪些(what）动作？

Executor比Thread更加灵活

线程池：管理一组同构工作线程的资源池，与工作队列密切相关。
工作队列保存所有等待执行的任务。
工作者线程从工作队列中获取一个任务，执行任务，然后返回线程池等待下一个任务。

优势：

减少在线程创建和销毁过程中的开销。
由于线程早于任务存在，提高了响应性。
防止过多线程相互竞争导致的内存耗尽。

JDK中提供了很多工厂方法来创建一些有用的默认配置线程池。

newFixedThreadPool: 固定大小、每当提交一个任务就创建一个线程直到达到最大数量，如果有线程退出(异常等),线程池将补充新的线程
newCachedThreadPool: 可缓冲的线程池、当线程数>任务数时回收空闲线程，任务增加时添加新的线程，不存在规模限制。
newSingleThreadExecutor:单线程的Executor、单个工作者、如果当前worker挂掉会创建替补、按照任务队列顺序执行。
newScheduledThreadPool:固定长度、以定时或者延迟来执行任务。
通过使用Executor，可以实现各种调优、管理、监视、记录日志、错误报告、和其它功能。

6.2.4 Executor的生命周期
线程池创建后处于RUNNING状态。
JVM只有在所有（非守护）线程全部终止后才会退出–如果无法正常关闭Executor，那么JVM将无法正常结束。
Executor采用异步的方式（提交的任务并不立即执行），提交的任务存在三种状态：
1.已经完成；2.正在运行；3.在等待队列。
可以采用1.平缓的方式（等待所有的任务完成后结束）；2.最暴力的关闭方式（类似于直接拔电）。
为了解决执行服务的生命周期问题，Executor扩展了ExecutorService接口，添加了一些用于生命周期的方法。

// ExecutorService中生命周期的管理方法
public interface ExecutorService extends Executor{
	void shutdown(); // 不再接受新的任务，同时等待已经提交的任务执行完成--包括那些还未执行的任务。
	List<Runnable> shutdownNow();//取消所有运行的任务，不再启动队列中尚未开始执行的任务
	boolean isShutdown();
	boolean isTerminated(); // 可以用于轮询ExecutorService是否已经终止
	// 等待ExecutorService到达终止状态
	boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException;
	// .....其它用于任务提交的方法

在ExecutorService关闭后提交的任务将由拒绝执行处理器来处理，它会抛弃任务，使得executor方法抛出未检查的RejectedExecutionException异常。
通常在调用awaitTermination之后会立即调用shutdown，从而产生同步关闭ExecutorService的效果。

ExecutorService executorService = Executors.newFixedThreadPool(10); // 调用工厂方法创建线程池--固定大小

executorService.execute(new Runnable() {
	// Runnable接口的匿名实现类作为参数被传递给execute()方法。Runable将会被ExecutorService中的一个线程来执行。
    public void run() {
        System.out.println("Asynchronous task");
    }
});

executorService.shutdown(); // 平缓关闭线程池

下图说明了一个线程委派一个任务给线程池的异步执行流程：

一旦Thread1把当前任务分配给ExecutorService之后，Thread1继续执行当前任务之外的其它任务，ExecutorService将会独立于Thread1并同步的执行这个Thread1提交的任务-----异步

Java.util.concurrent.ThreadPoolExecutor类是ExecutorSerivce接口的具体实现。ThreadPoolExecutor使用线程池中的一个线程来执行给定的任务（Runnable或者Runnable）。

int  corePoolSize  =    5;
int  maxPoolSize   =   10;
long keepAliveTime = 5000;

ExecutorService threadPoolExecutor =
        new ThreadPoolExecutor(
                corePoolSize, //该线程池中【核心】线程数最大值:核心线程一直会在线程池中，即使什么都不干；非核心线程长时间闲置会被销毁
                maxPoolSize,  //线程总数的最大值=核心线程+非核心线程
                keepAliveTime,//非核心线程闲置超时时长
                TimeUnit.MILLISECONDS,// keepAliveTime的单位
                new LinkedBlockingQueue<Runnable>() // 阻塞队列--维护等待执行的Runnable任务对象
                );

详情请移步->

通过增加生命周期支持来扩展Web服务器功能。可以通过两种方法来关闭Web服务器：在程序中调用stop，或者以客户端请求形式向Web服务器发送一个特定格式的HTTP请求。

class LifecycleWebServer{
	private final ExecutorService exec = Executors.newFixedThreadPool(num);
	public void start() throws IOException{
		ServerSocket socket = new ServerSocket(80);
		while(!exec.isShutdown()){
			try{
				final Socket conn = socket.accept();
				exec.execute(new Runnable(){ // 提交任务
					public void run(){
						handleRequest(conn);}
				});
			} catch (RejectedExecutionException e){
				if (!exec.isShutdown()){
					log("task submission rejected", e);
				}
			}
		}
	// 停止当前的线程池
	public void stop(){ exec.shutdown();}

	// 具体的处理发送来的请求
	void handleRequest(Socket connection){
		Request req = readRequest(connection);
		if (isShutdownRequest(req)){
			stop();
		} else {
			dispatchRequest(req);
		}
	}