JAVA并发处理经验(二)JAVA线程池运用与并发工具

一、前言

前面一章是对县城池，自己的理解总结。只限目录

二、线程池

1】线程池主要都是ThreadpoolExetor都是Executors工厂生成

2】生成线程线程池分类：

newFIxedThread=============返回固定大小的线程池

newSingleThreadExecutor======返回单线程处理

newCachedThreadPool=======返回逐步增加线程数量的线程

newSingleThreadScheduleExecutor====单线程（有周期执行）计划线程

newScheduleThreadPool=========制定线程数量（有周期执行）

 1‘newScheduleThreadPool具体方法

  1’1 sheduleAtFixedRate：固定频率

                 1‘2 sheduleWithfixedDalay：相当频率

3】线程都有队列与拒绝策略

3’1synchronousQueue 直接提交队列

        3‘2 arrayBlokingQueue 有界队列

        3’3 LInkedBlokingQueue无界队列

       3‘4prirorityBlockingQueuq 优先级队列

 4】拒绝策略

4’1 abortPloicy策略 直接异常，阻止系统正常工作

        4‘2 CallerRunPolicy 一直霸占资源慢慢执行

        4’3 DiscardOldedestPloicy 丢弃最老的策略

        4‘4 DiscardPolicy 默默丢弃，程序不受困

5】ThreadPoolExecutor 提供before after等方法

6】线程池线程都可以自己线程创建ThreadFactory，但是一般都用默认即够用。

7】Runtime.getRuntime().availableProcessors 测试系统设置线程池的数量

8】在使用线程池execute与submit的区别；一般用submit获取异常

9】如果你需要可以自己扩展线程池【有效确定找到你程序报错地点】【一般看submit的futer应该够用】

10】JDK 7之后新的From/Join线程池，代码如下

package jDKMulit;

import java.util.ArrayList;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveTask;

/**
 * Created by ycy on 16/1/13.
 */
public class CountTaskForkJoin extends RecursiveTask<Long> {
    private static final int THEESHOLD = 10000;
    private long start;
    private long end;

    public CountTaskForkJoin(long start, long end) {
        this.start = start;
        this.end = end;
    }

    @Override
    public Long compute() {
        long sum = 0;
        boolean canCpmpute = (end - start) < THEESHOLD;
        if (canCpmpute) {
            for (long i = start; i <= end; i++) {
                sum += i;
            }
        } else {
            //分为100个小任务
            long step = (start + end) / 100;
            ArrayList<CountTaskForkJoin> subTasks = new ArrayList<CountTaskForkJoin>();
            long pos = start;
            for (int i = 0; i < 100; i++) {
                long lastOne = pos + step;
                if (lastOne > end) lastOne = end;
                CountTaskForkJoin subTask = new CountTaskForkJoin(pos, lastOne);
                pos += step + 1;
                subTasks.add(subTask);
                subTask.fork();

            }
            for (CountTaskForkJoin t : subTasks) {
                sum += t.join();
            }
        }
        return sum;
    }

    public static void main(String[] args) {
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        CountTaskForkJoin task = new CountTaskForkJoin(0, 200000l);
        ForkJoinTask<Long> rsult = forkJoinPool.submit(task);
        try {
            long res = rsult.get();
            System.out.println("sum=" + res);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

11】JDK下面的并发容器

11.1  ConcurrentHashmap：线程安全hsamap

112. CopyOnwriteArrayList:快速读取的list

        11.3ConcurrentLinkList：线程安全的LIkedList

        11.4BlockingQueue：线程阻塞的数据队列

        11.5ConcurrentSkipListMap：跳表

11.6 高效读写队列：ConcurrentLinkedQueue