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*/
