关于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();*/