java并发包 1.java并发包介绍 线程不能无限制的new下去，否则系统处理不了的。 使用线程池。任务来了就开一runable对象。 concurrent 包开始不是jdk里面的，后来加入到jdk里面去了。 当很多人来访问网站的时候，就要开启一个队列，排队处理请求，这个队列用JMS-ActiveMQ实现。有抢手机的队列，有抢电脑的队列，不同的队列。 为不同的“主题”建立消息队列。 主要包含原子量、并发集合、同步器、可重入锁。
线程池的5中创建方式： 1、Single Thread Executor : 只有一个线程的线程池，提交很多任务给线程池的时候，只有一个线程，就是单线程，因此所有提交的任务是顺序执行， 代码： Executors.newSingleThreadExecutor() 2、Cached Thread Pool : 线程池里有很多线程需要同时执行，老的可用线程将被新的任务触发重新执行，如果线程超过60秒内没执行，那么将被终止并从池中删除， 代码：Executors.newCachedThreadPool() 3、Fixed Thread Pool : 拥有固定线程数的线程池，如果没有任务执行，那么线程会一直等待， 代码： Executors.newFixedThreadPool(4) 在构造函数中的参数4是线程池的大小，你可以随意设置，也可以和cpu的核数量保持一致，获取cpu的核数量int cpuNums = Runtime.getRuntime().availableProcessors(); getRuntime是获取运行环境。 线程的数量与cpu、和任务是否IO密集型还是运算密集型有关。 4、Scheduled Thread Pool : 用来调度即将执行的任务的线程池，可能不是直接执行, 每隔5分钟执行一次。策略型的 代码：Executors.newScheduledThreadPool() 5、Single Thread Scheduled Pool : 只有一个线程，用来调度任务在指定时间执行，代码：Executors.newSingleThreadScheduledExecutor()
public class ExecutorDemo { public static void main(String[] args) { ExecutorService newSingleThreadExecutor = Executors.newSingleThreadExecutor(); ExecutorService newCachedThreadPool = Executors.newCachedThreadPool(); int cpuNums = Runtime.getRuntime().availableProcessors(); System.out.println(cpuNums);//核的数量 ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(cpuNums); ScheduledExecutorService newScheduledThreadPool = Executors.newScheduledThreadPool(8); ScheduledExecutorService newSingleThreadScheduledExecutor = Executors.newSingleThreadScheduledExecutor(); } }
线程池的使用 提交 Runnable ，任务完成后 Future 对象返回 null 调用excute,提交任务, 匿名Runable重写run方法, run方法里是业务逻辑 见代码：ThreadPoolWithRunable 提交 Callable，该方法返回一个 Future 实例表示任务的状态 调用submit提交任务, 匿名Callable,重写call方法, 有返回值, 获取返回值会阻塞,一直要等到线程任务返回结果 见代码：ThreadPoolWithcallable
package cn.itcast_01_mythread.pool; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class ThreadPoolWithRunable { /** * 通过线程池执行线程 * @param args */ public static void main(String[] args) { //创建一个线程池，可回收的，没任务就回收了。newCachedThreadPool可以很大。60秒没任务就回收。 ExecutorService pool = Executors.newCachedThreadPool();//线程池 for(int i = 1; i < 5; i++){//4个任务，一个任务就是一个Runnable pool.execute(new Runnable() {//没有返回值 @Override public void run() { System.out.println("thread name: " + Thread.currentThread().getName()); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } }); } pool.shutdown();//任务执行完就关了。 } } /*thread name: pool-1-thread-3 thread name: pool-1-thread-1 thread name: pool-1-thread-4 thread name: pool-1-thread-2 */
package cn.itcast_01_mythread.pool; import java.util.ArrayList; import java.util.List; import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future; /** * callable 跟runnable的区别： * runnable的run方法不会有任何返回结果，所以主线程无法获得任务线程的返回值， * 如果要用到结果，那么就用共享变量并且加锁。 * * callable的call方法可以返回结果，但是主线程在获取时是被阻塞，需要等待任务线程返回才能拿到结果 * @author * */ public class ThreadPoolWithcallable { public static void main(String[] args) throws InterruptedException, ExecutionException { ExecutorService pool = Executors.newFixedThreadPool(4); //线程池 //提交3个任务，Callable有返回值，从里面的任务返回回来的。 for(int i = 0; i < 3; i++){ //子线程什么时候执行完，主线程是不知道的，现在要从子线程拿到返回值，这里用的是回调。 //所以submit只是一个句柄（一个引用，开始没值后来有值） Future<String> submit = pool.submit(new Callable<String>(){//子线程开始执行 @Override public String call() throws Exception {//run方法。返回值不一定是string。 Thread.sleep(3000); return "b--"+Thread.currentThread().getName(); } }); //submit.get()是在主线程执行的。主线程从Future中get结果，这个方法是会被阻塞的， //因为一直要等到子线程任务执行完才可以拿到结果，否则拿不到结果。 //如果这个子线程卡死了，那么主线程就卡死了。少用返回结果。 System.out.println(submit.get()); } pool.shutdown(); }} /* b--pool-1-thread-1 ：等待3秒钟阻塞 b--pool-1-thread-2 ：等待3秒钟阻塞 b--pool-1-thread-3 ：等待3秒钟阻塞 */
package cn.itcast_01_mythread.pool; import java.util.ArrayList; import java.util.HashMap; import java.util.Random; import java.util.concurrent.Callable; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future; import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.TimeUnit; import com.sun.corba.se.impl.encoding.OSFCodeSetRegistry.Entry; public class TestPool { public static void main(String[] args) throws Exception { Future<?> submit = null; Random random = new Random(); //创建固定数量线程池 // ExecutorService exec = Executors.newFixedThreadPool(4); //创建调度线程池 ScheduledExecutorService exec = Executors.newScheduledThreadPool(4); //用来记录各线程的返回结果 ArrayList<Future<?>> results = new ArrayList<Future<?>>(); for (int i = 0; i < 5; i++) { //fixedPool提交线程，runnable无返回值，callable有返回值 /*submit = exec.submit(new TaskRunnable(i));*/ /*submit = exec.submit(new TaskCallable(i));*/ //schedulerPool可以用submit和schedule提交 //对于schedulerPool来说，调用submit提交任务时，跟普通pool效果一致，没有时间间隔的调度执行。 /*submit = exec.submit(new TaskCallable(i));*/ //对于schedulerPool来说，调用schedule提交任务时，则可按延迟多少秒之后再启动，按间隔时长来调度线程的运行 submit = exec.schedule(new TaskCallable(i), random.nextInt(10), TimeUnit.SECONDS); //存储线程执行结果， //先把所有句柄保存起来，submit是一个句柄一个引用，此时不会立即有值，只有子线程执行完之后句柄才有值，才可以get出来值。 results.add(submit); System.out.println("完毕"); } //打印结果 for(Future f: results){ boolean done = f.isDone(); System.out.println(done?"已完成":"未完成"); //从结果的打印顺序可以看到，即使未完成，主线程也会阻塞等待 System.out.println("" + f.get()); } exec.shutdown(); }} class TaskCallable implements Callable<String>{ private int s; Random r = new Random(); public TaskCallable(int s){ this.s = s; } @Override public String call() throws Exception { String name = Thread.currentThread().getName(); long currentTimeMillis = System.currentTimeMillis(); System.out.println(name+" 开始启动-s-" + s); int rint = r.nextInt(3); try { Thread.sleep(rint*1000); } catch (InterruptedException e) { e.printStackTrace(); } // System.out.println(name + " 结束启动-s-"+s); return name + " 结束启动-s-"+s+ "-返回结果-" + s+""; }} class TaskRunnable implements Runnable{ private int s; public TaskRunnable(int s){ this.s = s; } Random r = new Random(); @Override public void run() { String name = Thread.currentThread().getName(); long currentTimeMillis = System.currentTimeMillis(); System.out.println(name+" 启动时间：" + currentTimeMillis/1000); int rint = r.nextInt(3); try { Thread.sleep(rint*1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(name + " is working..."+s); }} /*完毕 完毕 完毕 完毕 完毕 未完成 pool-1-thread-1 开始启动-s-1 pool-1-thread-2 开始启动-s-0 pool-1-thread-2 结束启动-s-0-返回结果-0 已完成 pool-1-thread-1 结束启动-s-1-返回结果-1 未完成 pool-1-thread-3 开始启动-s-2 pool-1-thread-4 开始启动-s-3 pool-1-thread-1 开始启动-s-4 : 线程1结束后又开始执行新的任务 pool-1-thread-3 结束启动-s-2-返回结果-2 已完成 pool-1-thread-4 结束启动-s-3-返回结果-3 未完成 pool-1-thread-1 结束启动-s-4-返回结果-4*/