关于java 线程/线程池 的处理以及运用 笔记

1. 创建线
   1.1继承Thread 类 。。。 略
   1.2 实现Runnable 接口（无返回值）。。。略
   1.3 实现Callable 接口（带返回值）

public class TestCallableThread implements Callable<String> {    private List<String> list;    public TestCallableThread(List<String> list) {        this.list = list;    }    @Override    public String call() throws Exception {        String name = Thread.currentThread().getName();        System.out.println("当前线程是：" + name);        for (String str : list) {            System.out.println("输出的结果是：" + str);        }        return "over";    }

1.4 实现ThreadFactory 接口（自定义线程对象）

import java.util.concurrent.ThreadFactory;public class Test3 implements ThreadFactory {    private String threadName;    public Test3(String threadName) {        this.threadName = threadName;    }    @Override    public Thread newThread(Runnable r) {        Thread thread = new Thread(r);        thread.setName(threadName);        return thread;    }}

    //只需要调用此线程即可    //获取此线程的对象    Test3 testThread = new Test3("测试ThreadFactory 线程");    Thread thread = testThread.newThread(new Runnable() {        @Override        public void run() {            // TODO Auto-generated method stub            //添加线程的实现        }    });        thread.start();  //启动线程

1. 线程池

   2.1 通过Executors 类创建线程池

   • newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

   • newFixedThreadPool创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。

   • newScheduledThreadPool创建一个定长线程池，支持定时及周期性任务执行。

   • newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

    //创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程    //线程池为无限大，当执行第二个任务时第一个任务已经完成，会复用执行第一个任务的线程，而不用每次新建线程    ExecutorService cachedThreadPool = Executors.newCachedThreadPool();    for (int i = 0; i < 10; i++) {        final int index = i;        try {            Thread.sleep(index * 1000);        }catch (InterruptedException e) {            e.printStackTrace();        }        cachedThreadPool.execute(new Runnable() {            @Override            public void run() {               System.out.println(index);            }        });    }//创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);for (int i = 0; i < 10; i++) {    final int index = i;    fixedThreadPool.execute(new Runnable() {        @Override        public void run() {           try {               System.out.println(index);               Thread.sleep(2000);            } catch (InterruptedException e) {               // TODO Auto-generated catch block               e.printStackTrace();             }         }     });}//创建一个定长线程池，支持定时及周期性任务执行ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);scheduledThreadPool.schedule(new Runnable() {   @Override   public void run() {      System.out.println("delay 3 seconds");   }}, 3, TimeUnit.SECONDS);scheduledThreadPool.scheduleAtFixedRate(new Runnable() {   @Override   public void run() {    System.out.println("delay 1 seconds, and excute every 3 seconds");}}, 1, 3, TimeUnit.SECONDS);//创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();for (int i = 0; i < 10; i++) {   final int index = i;   singleThreadExecutor.execute(new Runnable() {      @Override      public void run() {         try {             System.out.println(index);             Thread.sleep(2000);          } catch (InterruptedException e) {             // TODO Auto-generated catch block             e.printStackTrace();          }       }   });}

4.Future

//FutureTask 简介实现了Future接口，ExecutorService executor = Executors.newCachedThreadPool();        Task task = new Task();        Future<Integer> result = executor.submit(task);        executor.shutdown(); //第一种方式        ExecutorService executor = Executors.newCachedThreadPool();        Task task = new Task();        FutureTask<Integer> futureTask = new FutureTask<Integer>(task);        executor.submit(futureTask);        executor.shutdown();        //第二种方式，注意这种方式和第一种方式效果是类似的，只不过一个使用的是ExecutorService，一个使用的是Thread        //FutureTask 简介实现了Future接口 和Runnable 接口        /*Task task = new Task();        FutureTask<Integer> futureTask = new FutureTask<Integer>(task);        Thread thread = new Thread(futureTask);        thread.start();*/