java线程池笔记及相关代码

java线程池笔记：
线程池好处：
重用存在的线程，减少对象创建、消亡的开销，性能佳。

可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免堵塞。

提供定时执行、定期执行、单线程、并发数控制等功能。

java提供四个常用线程池
1.Executors是线程池顶级类。
2.ExecutorService 线程池类型.execute();
可缓存：newCachedThreadPool();
并发数控制：newFixedThreadPool(int num);
单线程：newSingelThreadPool();
定时执行、定期执行：newScheduledThreadPool();其二方法scheduleAtFixedRate(new Thread(), init延迟, 周期, TimeUnit.SECONDS);/scheduledthread.schedule(thread,time,unit);

代码实现：

/**
 * java线程池
 * @author joker
 */
package com.Threadp;

import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

class Threadtest implements Runnable {
	public int index;

	public Threadtest(int ind) {
		this.index = ind;
	}

	@Override
	public void run() {
		// TODO 自动生成的方法存根
		System.out.print("\n第" + index + "线程被唤醒。。");
		int i = 0;
		while (i < 4) {
			try {
				Thread.sleep(500);
				System.out.print(index + "->");
			} catch (InterruptedException e) {
				// TODO 自动生成的 catch 块
				e.printStackTrace();
			}
			i++;
		}
	}
}

public class Threadpool {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		// Executors线程池父类java.util.concurrent.Executor
		// 线程池好处：回收线程创立与消耗造成的不必要消耗
		// 高并发处理
		/**
		 * newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
		 * newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。 newScheduledThreadPool
		 * 创建一个定长线程池，支持定时及周期性任务执行。 newSingleThreadExecutor
		 * 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
		 * 
		 */
		/*
		 * 可缓存的线程池 线程池为无限大，当执行第二个任务时第一个任务已经完成，会复用执行第一个任务的线程，而不用每次新建线程。
		 */
		System.out.println("\n===========================================");
		ExecutorService cachedthread = Executors.newCachedThreadPool();
		System.out.println("可缓存线程池创建。。。" + "&(等待执行性)");
		for (int i = 0; i < 3; i++) {
			try {
				Thread.sleep(i * 1000);
				System.out.println(i + "新线程被创建");

			} catch (InterruptedException e) {
				// TODO 自动生成的 catch 块
				e.printStackTrace();
			}
			cachedthread.execute(new Runnable() {

				@Override
				public void run() {
					// TODO 自动生成的方法存根
					System.out.println("新线程被唤醒");
				}
			});
		}
		cachedthread.shutdown();
		System.out.println("\n可缓存线程池销毁。。。");
		/*
		 * 定长线程池 可控制线程最大并发数，超出的线程会在队列中等待
		 */
		System.out.println("\n===========================================");
		ExecutorService fixedthread = Executors.newFixedThreadPool(3);
		System.out.println("\n\n定长线程池创建。。。(长度3)" + "&(超出线程池则线程等待)");
		for (int i = 1; i < 6; i++)
			fixedthread.execute(new Threadtest(i));
		try {
			Thread.sleep(10000);
		} catch (InterruptedException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}
		fixedthread.shutdown();
		System.out.println("\n===========================================");
		System.out.println("\n定长线程池销毁。。。等待执行型");

		System.out.println("\n\n定长线程池创建。。。" + "&(周期性执行，延迟执行)");
		ScheduledExecutorService scheduledthread = Executors.newScheduledThreadPool(4);
		// 周期执行
		System.out.println("周期执行2秒");
		// scheduleAtFixedRate(new Thread(), init延迟, 周期, TimeUnit.SECONDS);
		scheduledthread.scheduleAtFixedRate(new Threadtest(new Random().nextInt(5)), 0, 2, TimeUnit.SECONDS);
		System.out.println("延迟执行");
		scheduledthread.schedule(new Runnable() {

			@Override
			public void run() {
				// TODO 自动生成的方法存根
				System.out.println("延迟执行5秒\n");
			}
		}, 5, TimeUnit.SECONDS);
		try {
			Thread.sleep(7000);
		} catch (InterruptedException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}
		scheduledthread.shutdown();
		System.out.println("\n定长线程池销毁。。。周延型");
		
		System.out.println("\n===========================================");
		System.out.println("\n\n定长线程池创建。。。" + "&(单线程池)");
		ExecutorService singelthread=Executors.newSingleThreadExecutor();
		singelthread.execute(new Threadtest(9999));
		try {
			Thread.sleep(8000);
		} catch (InterruptedException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}
		singelthread.shutdown();
		System.out.println("\n定长线程池销毁。。。单线程池型");
	}

}