java并发库java.util.concurrent各类的使用示例

最新推荐文章于 2021-03-04 22:12:03 发布

小样儿0611

最新推荐文章于 2021-03-04 22:12:03 发布

阅读量813

点赞数

本文链接：https://blog.csdn.net/xiaoyang0611/article/details/43560221

版权

本文详细介绍了Java并发库java.util.concurrent中的关键类和接口，包括ExecutorService、ThreadPoolExecutor、Future、Callable等的使用示例，帮助开发者掌握并发编程技巧。

摘要由CSDN通过智能技术生成

Executor

package concurrent.executor;

import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;

/**
 * Executors类，提供了一系列工厂方法用于创先线程池，返回的线程池都实现了ExecutorService接口。
 * public static ExecutorService newFixedThreadPool(int nThreads)
 * 创建固定数目线程的线程池。
 * public static ExecutorService newCachedThreadPool()
 * 创建一个可缓存的线程池，调用execute 将重用以前构造的线程（如果线程可用）。如果现有线程没有可用的，则创建一个新线程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。
 * public static ExecutorService newSingleThreadExecutor()
 * 创建一个单线程化的Executor。
 * public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)
 * @author xiaoyang
 *
 */
public class TaskExecutorWebServer {
	
	private static final Executor exec=Executors.newFixedThreadPool(100);

	public static void main(String[] args) throws Exception {
		
		ServerSocket ss=new ServerSocket(8888);
		
		while(true){

		    final	Socket connection= ss.accept();
		    Runnable task=new Runnable() {
				
				@Override
				public void run() {
					//handleRequest(connection);
				}
				
			};
			exec.execute(task);
		}
		
		
	}
}

<span style="font-size: 24px; font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);">Executorservice</span>

package concurrent.executorservice;

import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * ExecutorService扩展了Executor并添加了一些生命周期管理的方法。一个Executor的生命周期有三种状态，运行 ，关闭 ，终止 。Executor创建时处于运行状态。当调用ExecutorService.shutdown()后，处于关闭状态，isShutdown()方法返回true。这时，不应该再想Executor中添加任务，所有已添加的任务执行完毕后，Executor处于终止状态，isTerminated()返回true。
 *如果Executor处于关闭状态，往Executor提交任务会抛出unchecked exception RejectedExecutionException。
 * @author xiaoyang
 *
 */
public class LifecycleWebServer {
	
	private  final ExecutorService exec=Executors.newFixedThreadPool(100);
	
	
	public  void start() throws Exception {
		ServerSocket ss=new ServerSocket(8888);
		
		while(!exec.isShutdown()){
			
		    final	Socket connection= ss.accept();
		    Runnable task=new Runnable() {
				
				@Override
				public void run() {
					//handleRequest(connection);
				}
				
			};
			exec.execute(task);
		}
		
		
	}
	
	public void stop(){
		exec.shutdown();
	}
	
	
	
}

package concurrent.executorservice;

import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 * Future<V>代表一个异步执行的操作，通过get()方法可以获得操作的结果，如果异步操作还没有完成，则，get()会使当前线程阻塞。FutureTask<V>实现了Future<V>和Runable<V>。Callable代表一个有返回值得操作。
 * @author xiaoyang
 */
public class CallableLifecycleWebServer {
	
	private  final ExecutorService exec=Executors.newFixedThreadPool(100);
	
	
	public  void start() throws Exception {
		ServerSocket ss=new ServerSocket(8888);
		
		while(!exec.isShutdown()){
			
		    final	Socket connection= ss.accept();
		    Callable<Object> task=new Callable<Object>() {
				
				@Override
				public Object call() {
					//return handleRequest(connection);
					return null;
				}
				
			};
			Future<Object> f= exec.submit(task);
			Object result= f.get();
		}
		
		
	}
	
	public void stop(){
		exec.shutdown();
	}
	
	
	
}

ExecutorThreadPool

package concurrent.ExecutorThreadPool;

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

/**
 * ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, RejectedExecutionHandler handler)  

 *corePoolSize：池中所保存的线程数，包括空闲线程（非最大同时干活的线程数）。如果池中线程数多于 corePoolSize，则这些多出的线程在空闲时间超过 keepAliveTime 时将会终止。
 
 *maximumPoolSize：线程池中最大线程数
 
 *keepAliveTime：线程空闲回收的时间
 
 *unit：keepAliveTime的单位
 
 *workQueue：保存任务的队列，可以如下选择：
 
 * •  无界队列： new LinkedBlockingQueue<Runnable>();
 * •  有界队列： new ArrayBlockingQueue<Runnable>(8);你不想让客户端无限的请求吃光你的CPU和内存吧，那就用有界队列
 
 *handler：当提交任务数大于队列size会抛出RejectedExecutionException，可选的值为：
 
 * •ThreadPoolExecutor.CallerRunsPolicy 等待队列空闲
 *•ThreadPool