Java并发学习1

java并发库所包含的东西
Executor ：具体Runnable任务的执行者。
ExecutorService ：一个线程池管理者，其实现类有多种，我会介绍一部分。我们能把Runnable,Callable提交到池中让其调度
Semaphore ：一个计数信号量
ReentrantLock ：一个可重入的互斥锁定 Lock，功能类似synchronized，但要强大的多。
Future ：是与Runnable,Callable进行交互的接口，比如一个线程执行结束后取返回的结果等等，还提供了cancel终止线程。
BlockingQueue ：阻塞队列。
CompletionService : ExecutorService的扩展，可以获得线程执行结果的
CountDownLatch ：一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。
CyclicBarrier ：一个同步辅助类，它允许一组线程互相等待，直到到达某个公共屏障点
Future ：Future 表示异步计算的结果。
ScheduledExecutorService ：一个 ExecutorService，可安排在给定的延迟后运行或定期执行的命令。

一、Executors
Executors工具类是用于创建线程池的，可以指定线程池的大小（线程的数量），也可以不指定大小，也可以指定定时器的线程池。下面来一一看看。
1、newFixedThreadPool（固定大小线程池）

package sychrionizer;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ExecutorsTest {
    public static void main(String[] args) {
        //创建了一个5个线程的线程池 
        ExecutorService pool = Executors.newFixedThreadPool(5);

        for(int i = 0 ; i < 5 ; i++){
            //执行线程
            pool.execute(new MyThread());
        }
        //任务执行完关闭线程池
        pool.shutdown();
        //立即关闭
        //pool.shutdownNow();
    }

}
/**
 * 线程
 * @author Errol
 *
 */
class MyThread implements Runnable{
    @Override
    public void run() {
        System.out.println("线程"+ Thread.currentThread().getName()+"执行中...");
    }
}

用此方法创建的线程池以无界队列的方式运行这些程序，如果有线程过来，就会在一个队列中等待空闲的线程。如果线程池关闭前，线程执行失败导致线程终止，则将会有一个新的线程代替该线程，继续执行剩余任务。

2、newCachedThreadPool（缓存线程池）

package sychrionizer;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ExecutorsTest {
    public static void main(String[] args) {
        //创建的线程池 
        ExecutorService pool = Executors.newCachedThreadPool();

        for(int i = 0 ; i < 5 ; i++){
            //执行线程
            pool.execute(new MyThread());
        }
        //任务执行完关闭线程池
        pool.shutdown();
        //立即关闭
        //pool.shutdownNow();
    }

}
/**
 * 线程
 * @author Errol
 *
 */
class MyThread implements Runnable{
    @Override
    public void run() {
        System.out.println("线程"+ Thread.currentThread().getName()+"执行中...");
    }
}

什么是缓存线程池，说白了，就是线程池大小可变的，线程池的大小依赖与任务数量，任务数量多，则线程池就增大，任务数量少了，则线程池将多余的空闲线程关闭掉，达到可变的目的。如上面的代码，如果循环数量变为10，那么，则创建出10个线程出来。

3、newSingleThreadExecutor()（单个线程线程池）
代码与上面类似，只需要将创建线程池的方法改为创建单个线程线程池。区别在哪呢？
单个线程池执行任务，是由一个线程执行的，这可以由输出结果得出该结论。
那单个线程线程池与我们普通的new Thread()的方式有什么区别呢？
线程池的好处就是，如果该线程死了，线程池将会重新创建出一个线程来执行剩余的任务。而我们new 的方法中，如果任务失败了，我们只能重新new一个线程出来执行了。

4、newScheduledThreadPool(int corePoolSize)（定时器线程池）
我们可以用静态方法newScheduledThreadPool(int corePoolSize)来定义一个定时器线程池，可以指定线程个数。然后再调用schedule方法，传进去一个Runnable和定时时长即可。

package sychrionizer;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class ExecutorsTest {
    public static void main(String[] args) {
        //创建的线程池 
        ScheduledExecutorService pool = Executors.newScheduledThreadPool(5);

        for(int i = 0 ; i < 5 ; i++){
            //执行线程
            pool.schedule(new MyThread(), 2, TimeUnit.SECONDS);
        }
        //任务执行完关闭线程池
        pool.shutdown();
        //立即关闭
        //pool.shutdownNow();
    }

}
/**
 * 线程
 * @author Errol
 *
 */
class MyThread implements Runnable{
    @Override
    public void run() {
        System.out.println("线程"+ Thread.currentThread().getName()+"执行中...");
    }
}

上面的代码中，创建了一个定时器线程池，长度是5，循环执行5个任务，且线程池在延迟2秒之后开始执行，。
如果需要延迟2秒之后开始执行任务，且，每间隔2秒执行一个任务怎么办？
将schedule方法修改为：
pool.scheduleAtFixedRate(new MyThread(), 2, 2, TimeUnit.SECONDS);
即可。