Java高并发编程---线程应用

等待超时模式

 所谓等待超时模式，大致就是调用一个方法时等待一段时间（一般来说是给定一个时间段），如果该方法能够在给定的时间段之内得到结果，那么将结果立刻返回，反之，超时返回默认结果。
怎么做：

• 定义等待持续时间：REMAINING=T。
• 定义超时时间：FUTURE=now+T。
• wait(REMAINING)

// 对当前对象加锁
public synchronized Object get(long mills) throws InterruptedException {
			long future = System.currentTimeMillis() + mills;
			long remaining = mills;
			// 当超时大于0并且result返回值不满足要求
			while ((result == null) && remaining > 0) {
				wait(remaining);
				remaining = future - System.currentTimeMillis();
			}
				return result;
}

 等待超时模式就是在等待/通知范式基础上增加了超时控制，这使得该模式相比原有范式更具有灵活性，因为即使方法执行时间过长，也不会“永久”阻塞调用者，而是会按照调用者的要求“按时”返回。
 

线程池

 对于服务端的程序，经常面对的是客户端传入的短小（执行时间短、工作内容较为单一）任务，需要服务端快速处理并返回结果。如果服务端每次接受到一个任务，创建一个线程，然后进行执行，这在原型阶段是个不错的选择，但是面对成千上万的任务递交进服务器时，如果还是采用一个任务一个线程的方式，那么将会创建数以万记的线程，这不是一个好的选择。因为这会使操作系统频繁的进行线程上下文切换，无故增加系统的负载，而线程的创建和消亡都是需要耗费系统资源的，也无疑浪费了系统资源。
 线程池技术能够很好地解决这个问题，它预先创建了若干数量的线程，并且不能由用户直接对线程的创建进行控制，在这个前提下重复使用固定或较为固定数目的线程来完成任务的执行。这样做的好处是，一方面，消除了频繁创建和消亡线程的系统资源开销，另一方面，面对过量任务的提交能够平缓的劣化。

ThreadPool.java

public interface ThreadPool<Job extends Runnable> {
		// 执行一个Job，这个Job需要实现Runnable
		void execute(Job job);
		// 关闭线程池
		void shutdown();
		// 增加工作者线程
		void addWorkers(int num);
		// 减少工作者线程
		void removeWorker(int num);
		// 得到正在等待执行的任务数量
		int getJobSize();
}

 客户端可以通过execute(Job)方法将Job提交入线程池执行，而客户端自身不用等待Job的执行完成。除了execute(Job)方法以外，线程池接口提供了增大/减少工作者线程以及关闭线程池的方法。这里工作者线程代表着一个重复执行Job的线程，而每个由客户端提交的Job都将进入到一个工作队列中等待工作者线程的处理。

DefaultThreadPool.java

public class DefaultThreadPool<Job extends Runnable> implements ThreadPool<Job> {
		// 线程池最大限制数
		private static final int MAX_WORKER_NUMBERS = 10;
		// 线程池默认的数量
		private static final int DEFAULT_WORKER_NUMBERS = 5;
		// 线程池最小的数量
		private static final int MIN_WORKER_NUMBERS = 1;
		// 这是一个工作列表，将会向里面插入工作
		private final LinkedList<Job> jobs = new LinkedList<Job>();
		// 工作者列表
		private final List<Worker> workers = Collections.synchronizedList(new
		ArrayList<Worker>());
		// 工作者线程的数量
		private int workerNum = DEFAULT_WORKER_NUMBERS;
		// 线程编号生成
		private AtomicLong threadNum = new AtomicLong();
		public DefaultThreadPool() {
			initializeWokers(DEFAULT_WORKER_NUMBERS);
		}
		public DefaultThreadPool(int num) {
			workerNum = num > MAX_WORKER_NUMBERS MAX_WORKER_NUMBERS : num < MIN_WORKER_
			NUMBERS MIN_WORKER_NUMBERS : num;
			initializeWokers(workerNum);
		}
		public void execute(Job job) {
			if (job != null) {
				// 添加一个工作，然后进行通知
				synchronized (jobs) {
					jobs.addLast(job);
					jobs.notify();
				}
			}
		}
		public void shutdown() {
			for (Worker worker : workers) {
				worker.shutdown();
			}
		}
		public void addWorkers(int num) {
			synchronized (jobs) {
				// 限制新增的Worker数量不能超过最大值
				if (num + this.workerNum > MAX_WORKER_NUMBERS) {
					num = MAX_WORKER_NUMBERS - this.workerNum;
			}
			initializeWokers(num);
			this.workerNum += num;
		}
		}
		public void removeWorker(int num) {
			synchronized (jobs) {
				if (num >= this.workerNum) {
					throw new IllegalArgumentException("beyond workNum");
				}
				// 按照给定的数量停止Worker
					int count = 0;
					while (count < num) {
						Worker worker = workers.get(count)
						if (workers.remove(worker)) {
							worker.shutdown();
						count++;
					}
		}
			this.workerNum -= count;
		}
		}
		public int getJobSize() {
			return jobs.size();
		}
		// 初始化线程工作者
		private void initializeWokers(int num) {
			for (int i = 0; i < num; i++) {
				Worker worker = new Worker();
				workers.add(worker);
				Thread thread = new Thread(worker, "ThreadPool-Worker-" + threadNum.
				incrementAndGet());
				thread.start();
			}
		}
		// 工作者，负责消费任务
		class Worker implements Runnable {
		// 是否工作
			private volatile boolean running = true;
			public void run() {
			while (running) {
			Job job = null;
			synchronized (jobs) {
				// 如果工作者列表是空的，那么就wait
				while (jobs.isEmpty()) {
					try {
					jobs.wait();
					} catch (InterruptedException ex) {
					// 感知到外部对WorkerThread的中断操作，返回
					Thread.currentThread().interrupt();
				return;
			}
		}
			// 取出一个Job
			job = jobs.removeFirst();
		}
				if (job != null) {
				try {
				job.run();
				} catch (Exception ex) {
				// 忽略Job执行中的Exception
					}
				}
			}
		}
			public void shutdown() {
				running = false;
			}
		}
}

 当客户端调用execute(Job)方法时，会不断地向任务列表jobs中添加Job，而每个工作者线程会不断地从jobs上取出一个Job进行执行，当jobs为空时，工作者线程进入等待状态。
 添加一个Job后，对工作队列jobs调用了其notify()方法，而不是notifyAll()方法，因为能够确定有工作者线程被唤醒，这时使用notify()方法将会比notifyAll()方法获得更小的开销（避免将等待队列中的线程全部移动到阻塞队列中）。
 

Web服务器高并发（线程池技术）

 目前的浏览器都支持多线程访问，比如说在请求一个HTML页面的时候，页面中包含的图片资源、样式资源会被浏览器发起并发的获取，这样用户就不会遇到一直等到一个图片完全下载完成才能继续查看文字内容的尴尬情况。大部分Web服务器都是支持并发访问的。常用的Java Web服务器，如Tomcat、Jetty，在其处理请求的过程中都使用到了线程池技术。
 下面使用线程池来构造一个简单的Web服务器，这个Web服务器用来处理HTTP请求，目前只能处理简单的文本和JPG图片内容。这个Web服务器使用main线程不断地接受客户端Socket的连接，将连接以及请求提交给线程池处理，这样使得Web服务器能够同时处理多个客户端请求。

SimpleHttpServer.java

public class SimpleHttpServer {
		// 处理HttpRequest的线程池
		static ThreadPool<HttpRequestHandler> threadPool = new DefaultThreadPool
		<HttpRequestHandler>(1);
		// SimpleHttpServer的根路径
		static String basePath;
		static ServerSocket serverSocket;
		// 服务监听端口
		static int port = 8080;
		public static void setPort(int port) {
			if (port > 0) {
				SimpleHttpServer.port = port;
			}
		}
		public static void setBasePath(String basePath) {
			if (basePath != null && new File(basePath).exists() && new File(basePath).
			isDirectory()) {
				SimpleHttpServer.basePath = basePath;
			}
		}
		// 启动SimpleHttpServer
		public static void start() throws Exception {
			serverSocket = new ServerSocket(port);
			Socket socket = null;
			while ((socket = serverSocket.accept()) != null) {
				// 接收一个客户端Socket，生成一个HttpRequestHandler，放入线程池执行
				threadPool.execute(new HttpRequestHandler(socket));
			}
			serverSocket.close();
		}
		static class HttpRequestHandler implements Runnable {
			private Socket socket;
			public HttpRequestHandler(Socket socket) {
				this.socket = socket;
			}
			@Override
			public void run() {
			String line = null;
			BufferedReader br = null;
			BufferedReader reader = null;
			PrintWriter out = null;
			InputStream in = null;
				try {
					reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
					String header = reader.readLine();
					// 由相对路径计算出绝对路径
					String filePath = basePath + header.split(" ")[1];
					out = new PrintWriter(socket.getOutputStream());
					// 如果请求资源的后缀为jpg或者ico，则读取资源并输出
					if (filePath.endsWith("jpg") || filePath.endsWith("ico")) {
						in = new FileInputStream(filePath);
						ByteArrayOutputStream baos = new ByteArrayOutputStream();
						int i = 0;
						while ((i = in.read()) != -1) {
							baos.write(i);
						}
						byte[] array = baos.toByteArray();
						out.println("HTTP/1.1 200 OK");
						out.println("Server: Molly");
						out.println("Content-Type: image/jpeg");
						out.println("Content-Length: " + array.length);
						out.println("");
						socket.getOutputStream().write(array, 0, array.length);
					} else {
						br = new BufferedReader(new InputStreamReader(new
						FileInputStream(filePath)));
						out = new PrintWriter(socket.getOutputStream());
						out.println("HTTP/1.1 200 OK");
						out.println("Server: Molly");
						out.println("Content-Type: text/html; charset=UTF-8");
						out.println("");
						while ((line = br.readLine()) != null) {
							out.println(line);
						}
				}
						out.flush();
					} catch (Exception ex) {
						out.println("HTTP/1.1 500");
						out.println("");
						out.flush();
					} finally {
						close(br, in, reader, out, socket);
					}
				}
			}
		// 关闭流或者Socket
		private static void close(Closeable... closeables) {
			if (closeables != null) {
				for (Closeable closeable : closeables) {
					try {
						closeable.close();
					} catch (Exception ex) {
					}
			}
		}
	}
}

 SimpleHttpServer在建立了与客户端的连接之后，并不会处理客户端的请求，而是将其包装成HttpRequestHandler并交由线程池处理。在线程池中的Worker处理客户端请求的同时，SimpleHttpServer能够继续完成后续客户端连接的建立，不会阻塞后续客户端的请求。

工作流程示意图：

 但是线程池中线程数量并不是越多越好，具体的数量需要评估每个任务的处理时间，以及当前计算机的处理器能力和数量。使用的线程过少，无法发挥处理器的性能；使用的线程过多，将会增加系统的无故开销，起到相反的作用。