cpf2016的专栏

1.最简单入门public class ThreadTest { @Test public void testExecute() { ExecutorService executorService = Executors.newFixedThreadPool(3); for (int i = 0; i < 5; i++) { executorService.exe

（1）作用          我们通常要使用线程来执行任务，任务通过Runnable定义，然后new 一个Thread来进行执行。          假如我们要改变一个Thread的名称，那么我们可以在new Thread的时候设置名称          那么如果我们需要对多个线程 都改名，难道每次new都要定义吗？          实际上我们可以通过ThreadFactory来

（1）含返回值           问题：1+2+...+100          1.思路             分解为1+2,3+4,，...99+100，然后对这50个结果进行求和          2.任务实现import java.util.concurrent.ExecutionException;import java.util.concurrent.Re

（1）背景               简单地说，就是如果说有一组任务的话，我们可以使用线程池，并发执行这些任务就可以提高运行效率了               但是，现在只有一个任务，而且这个任务可以拆分为一组不相关的子任务，这时就可以使用Fork/Join框架了               举个例子：              1.有50个1+2+..+100的任务   

错误程序public class Calculator extends RecursiveTask { private static final int THRESHOLD = 100; private int start; private int end; public Calculator(int start, int end) {

（1）继承关系              ThreadPoolExecutor：                           ForkJoinPool                               可以看出他们的父类都是AbstractExecutorService，所以也ForkJoinPool可以通过execute和submit来执行线程

（1）CheckedException                1.非线程解决方案                    对于CheckedException，通常可以通过try、catch或者声明抛出异常throws Exception2种方式来处理异常                2.线程解决方案                    定义线程会重写run方法，而r

（1）可以接受的任务类型               submit：                             execute：                           可以看出：                        execute只能接受Runnable类型的任务                        submit不

（1）作用                放弃当前线程的执行权，转给包括自己在内的其他线程执行（2）实例public class ThreadYieldTest { public static void main(String[] args) { for (int i=0; i<2; i++) { new Thread(new Runnable() {

（1）作用               实际上就是等待子线程执行完，主线程后面的代码才能执行（相当于wait）（2）实例               1.未使用joinimport java.util.concurrent.TimeUnit;public class JoinTest { public static void main(String[] args) {

1.引入      并发容器位于concurrent包中，相对于同步容器Vector和Hashtable，并发容器通过一些机制改进了并发性能。因为同步容器将所有对容器状态的访问都串行化了（synchronized），这样保证了线程的安全性，但是代价就是严重降低了并发性，当多个线程竞争容器时，吞吐量严重降低。因此引入了并发性能较好的并发容器，同同步容器相比，util.concurrent包中引入

1.基本思路      之前接触的队列都是非阻塞队列，不如LinkedList（实现了Dequeue接口）、PriorityQueue。使用非阻塞队列有一个很大的问题就是，它不会对当前线程产生阻塞。那么在面对类似生产者-消费者问题时，就必须额外实现同步策略以及线程间唤醒策略，这个实现起来非常麻烦。但是有了阻塞队列就不一样了，它会对当前线程产生阻塞。比如一个线程从一个空的阻塞队列中取元素，此时线

1.使用状态位关闭正在运行的线程class MyThread implements Runnable{ private volatile boolean stop = false; //定义为volatile类型，避免使用缓存 public void setStop(boolean stop) { this.stop = stop; } p

1.例子public class ThreadLocalTest { private static boolean flag = false; public static void main(String[] args) throws InterruptedException { new Thread(new Runnable() { @Override p

（1）守护线程定义

1.ThreadLocal源码解读      （1）get（）                get（）方法是用来获取ThreadLocal在当期线程中保存的变量副本。 public T get() { Thread t = Thread.currentThread(); //先获取当前线程 ThreadLoca

1.问题引入         线程之间也是需要协作的，比如生产者-消费者模型：当队列满时， 生产者需要等待队列中有空间才能够向里面放入物品，而在等待的时间内，生产者必须释放对资源（队列）的占有权。因为如果生产者不释放对资源的占有权，那么消费者就无法从队列中取出物品，就不会让队列有空间，进而生产者就会一直无限等待下去。因此，一般情况下，当队列满时，会让生产者交出占有权，并进入挂起状态。然后等待消

1.问题引入     创建线程有2中方式：直接继承Thread和实现Runnable接口。但是这2种方式都有一个缺陷，那就是执行完任务之后无法获取执行结果。     如果需要获取执行结果，就必须通过共享变量或者使用线程通信的方式来达到效果，但这样使用起来非常麻烦。     所以，自从jdk1.5之后，就提供了Callable和Future，通过他们可以获得任务执行完毕之后得到任务的执行

1）多线程作用            1.

1.基本思路        Copy-On-Write，是一种用于程序设计中的优化策略。基本思路是：从一开始大家都在共享同一个内容，当某个人想修改这个内容的时候，会把真正的内容Copy出去形成一个新的内容，然后再修改，这是一种延时懒惰策略。       CopyOnWrite容器，即写时复制容器。通俗理解就是，当我们向一个容器中添加元素的时候，不直接向容器添加，而是先将当前容器进行Copy

1.synchronize缺陷      代码块被synchronize修饰时，当一个线程获取了对应的线程锁并执行该代码块时，其他线程只能一直等待，直到获取锁的线程释放锁，而这里得到锁的线程释放锁只有两种情况：    （1）得到锁的线程执行完了该代码块，然后线程释放线程锁    （2）线程执行发生异常，此时JVM会让线程自动释放锁     如果这个得到锁的线程由于要等待IO或者其他

（1）作用                当使用ExecutorService启动了多个Callable之后，每个Callable会产生一个Future，通常我们需要将多个Future存入一个线性表中，用于之后的数据处理                CompletionService就是为此存在。它自身带有一个线程安全的线性表，无需用户创建。（2）使用