1.java并发包介绍

  JDK5.0 以后的版本都引入了高级并发特性,大多数的特性在java.util.concurrent 包中,是专门用于多线程并发编程的,充分利用了现代多处理器

和多核心系统的功能以编写大规模并发应用程序。主要包含原子量、并发集合、同步器、可重入锁,并对线程池的构造提供了强力的支持

2.线程池

  线程池是一种多线程处理形式,处理过程中将任务添加到队列,然后在创建线程后自动启动这些任务

2.1.线程池的5种创建方式

  1. Single Thread Executor : 只有一个线程的线程池,因此所有提交的任务是顺序执行

代码:

  2. Cached Thread Pool :线程池里有很多线程需要同时执行,老的可用线程将被新的任务触发重新执行,如果线程超过60秒内没执行,那么将

被终止并从池中删除,

  代码:Executors.newCachedThreadPool()

  3.  Fixed Thread Pool :拥有固定线程数的线程池,如果没有任务执行,那么线程会一直等待,

  代码: Executors.newFixedThreadPool(4)

  在构造函数中的参数4是线程池的大小,你可以随意设置,也可以和cpu的核数量保持一致,

  获取cpu的核数量:int cpuNums = Runtime.getRuntime().availableProcessors();

  4. Scheduled Thread Pool :用来调度即将执行的任务的线程池,可能是不是直接执行, 每隔多久执行一次... 策略型的

  代码:Executors.newScheduledThreadPool()

  5. Single Thread Scheduled Pool :只有一个线程,用来调度任务在指定时间执行,代码:Executors.newSingleThreadScheduledExecutor()

2.2.线程池的使用

并发包中各种线程池的用法及future获取任务返回结果的机制

1.提交 Runnable ,任务完成后 Future 对象返回 null,然后调用excute,提交任务, 匿名Runable重写run方法, run方法里是业务逻辑

package cn.thread;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolWithRunable {
    /**
     * 通过线程池执行线程
     * @param args
     */
    public static void main(String[] args) {
        //创建一个线程池
        ExecutorService pool = Executors.newCachedThreadPool();
        for(int i = 1; i < 5; i++){
            //提交任务
            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();
    }
}

 

2.提交 Callable,该方法返回一个 Future 实例表示任务的状态,调用submit提交任务, 匿名Callable,重写call方法, 有返回值, 获取返回值会阻塞,一直要等

到线程任务返回结果

package cn.thread;
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); 
        
        for(int i = 0; i < 10; i++){
            //提交一个返回值的任务用于执行,返回一个表示任务的未决结果的 Future。
            Future<String> submit = pool.submit(new Callable<String>(){
                @Override
                public String call() throws Exception {
                    //System.out.println("a");
                    Thread.sleep(5000);
                    return "b--"+Thread.currentThread().getName();
                }               
               });
            //从Future中get结果,这个方法是会被阻塞的,一直要等到线程任务返回结果
            System.out.println(submit.get());
        } 
            pool.shutdown();
    }
}