java 线程池

线程池

线程相关类、集合

16、线程池
Why? 系统启动一个新线程的成本比较高，因为涉及到与操作系统交互。这个时候用线程池可以很好的提高性能，
尤其是当程序中需要创建大量生存期很短暂的线程时，更应该考虑使用线程池。
原理：（流程）线程池和数据库连接池有点类似的是，线程池在系统启动时创建大量空闲线程，程序将一个Runnable对象传给线程池，
线程池就会启动一条线程来执行该线程对象的run方法，当run方法执行结束后，该线程并不会死亡，而是再次返回线程池中成为空闲线程，
等待执行下一个Runnable对象的run方法。

优点：使用线程池可以有效的控制系统中并发线程的数量，当系统中包含大量的并发线程时，会导致系统性能剧烈下降，
甚至导致JVM的崩溃，而线程池的最大线程参数可以控制系统中并发线程数目不超过此数目。

在JDK1.5开始，提供Java内建的线程池，JDK提供一个Executors工厂类来产生线程池，该工程类包含如下几个静态工厂方法来创建连接池：
A、newCachedThreadPool()：创建一个具有缓存功能的线程池，系统根据需要创建线程，这些线程将会被缓存在线程池中。
B、newFixedThreadPool(int nThreads)：创建一个可重用的、具有固定线程数的线程池
C、newSingleThreadExecutor()：创建一个只有单线程的线程池，它相当于newFixedThreadPool方法传递参数1
D、newScheduledThreadPool(int corePoolSize)：创建具有指定线程数的线程池，它可以在指定延迟后执行线程任务，
corePoolSize 指池中所保持的线程数，即使线程是空闲的也被保存在线程池内。
E、newSingleThreadScheduiedExecutor()：创建只有一条线程的线程池，它可以在指定延时后执行线程任务。
以上5个方法的前三个方法返回的是一个ExecutorService对象，该对象代表一个线程池，它可以执行Runnable对象或Callable对象所代表的线程。
而后两个方法返回一个ScheduledExecutorService线程池，它是ExecutorService的子类，它可以在指定延时后执行线程任务。

ExecutorService代表尽快执行线程的线程池（只要线程中有空闲的线程就立即执行线程任务）。
程序只要将一个Runnable对象或Callable对象（代表线程任务）提及给该线程池即可，该线程池就会尽快的执行任务。
ExecutorService里提供如下3个方法：
A、Future<?> submit(Runnable task)：将一个Runnable对象提交给指定的线程池。线程池将在有空闲线程时执行Runnable对象的代表的任务。
其中Future对象代表Runnable任务的返回值—run方法蛮腰返回值，所以Future对象将在run方法执行结束后返回null，
但可以调用Future的isDone，isCancelled方法来获得Runnable对象的执行状态
B、<T> Future<T> submit(Runnable task, T reslut)：将一个Runnable对象提及给指定的线程池，线程池将在有空闲线程时执行Runnable对象代表的任务，
result显示执行线程执行结束后的返回值，所以Future对象将在run方法执行结束后返回result
C、<T> Future<T> submit(Callable<T> task)：将一个Callable对象提交给指定线程池。线程池将在有空闲线程时执行Callable对象代表的任务，
Future代表Callable对象里的call方法的返回值

ScheduledExecutorService代表可在指定延迟或周期性执行线程任务的线程池，它提供了如下方法：
A、ScheduledFuture<V> schedule(Callable<V> callable, long delay, Timeout unit)：指定Callable任务将在delay延迟后执行
B、ScheduledFuture<V> schedule(Runnable command, long delay, Timeout unit)：指定command任务将在delay延迟后执行
C、ScheduleFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)
指定command任务将在delay延长后执行，而且以设定频率重复执行，也就是说，在initialDelay后开始执行，
异常在initialDelay+2* period 处重复运行，依次类推
D、ScheduleFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, Timeout unit)
创建并执行一个在给定初始延迟后首次启用的定期操作，随后，在每一次执行终止和下一次执行开始之间都存在给定的延迟。
如果任务的任一次运行遇到异常，就会取消后续运行。否则，只能通过程序来显示取消或终止任务
当用完一个线程池后，应该调用shutdown方法，该方法将启动线程池的关闭序列，调用了shutdown方法后线程池不再接受新的任务，
但会将以前所有一提交的任务执行完成。当线程池所有线程任务执行完毕后，池中所有线程都会死亡。另外也可以执行线程池的shutdownNow方法来关闭线程池，
该方法试图停止所有正在执行的活动任务，暂停处理正在等待的任务，并返回等待执行任务列表。
使用线程池来执行线程任务步骤：
A、调用Executors类的静态工厂方法创建一个ExecutorService对象，该对象代表一个线程池
B、创建Runnable实现类或是Callable实现类的实例，作为线程的执行任务
C、调用ExecutorService对象的submit方法来提交Runnable和Callable实例
D、当不想提交任务时调用ExecutorService对象的shutdown方法来关闭线程池

17、线程相关类
一、ThreadLocal类
在JDK5后ThreadLocal引入了泛型的支持，通过使用ThreadLocal可以简化多多线程的编程时是并发访问，使用这个工具类可以帮我们更好的实现多线程。
ThreadLocal，是Thread Local Variable（线程的局部变量）的意思。线程局部变量功能非常简单，就是为每一个使用该变量的线程都提供一个变量值的副本，
是每一个线程都可以独立的改变自己的副本，而不会和其他线程的副本冲突。
ThreadLocal提供常用方法：
A、T get()：返回此线程局部变量中当前线程副本中的值
B、void remove()：删除此线程局部变量中当前线程副本中的值
C、void set(T value)：设置此线程局部变量中当前线程副本中的值
ThreadLocal和其他所有同步机制都是为了解决多线程中对同一变量的访问冲突，在普通的同步机制中，是通过对象加锁来实现多个线程对同一变量的安全访问的。
在这种情形下，该变量是多个线程共享的，所以要使用这种同步机制需要很细致的分析在什么时候对变量进行读写，
上面时候需要锁定某个对象，什么时候释放对象锁等。
在这种情况下系统并没有将这份资源复制多份，只是采用了案情机制来控制队这份资源的访问而已。
ThreadLocal就从另一个角度来解决多线程的并发访问，ThreadLocal将需要并发访问的资源复制出多份，每个线程拥有一份资源，每个线程都拥有自己的资源副本，
从而也就没有必要对该变量进行同步了。ThreadLocal提供了线程安全的对象，在编写多线程代码时，可以把不安全的整个变量封装进ThreadLocal，
或者把该对象与现场相关的状态使用ThreadLocal保存。
ThreadLocal并不能代替同步机制，两者面向的问题领域不同。同步机制是为了同步多个线程对相同资源的并发访问，是多个线程之间进行通信的有效方式；
而ThreadLocal是隔离多个线程的数据共享，从根本上避免了多个线程之间共享资源（变量），也就不需要对多个线程进行同步了。
通常认为：如果需要进行多个线程之间的共享资源，已到达线程之间的通信功能，就使用步机制，如果仅仅需要隔离多个线程之间的共享冲突，就用ThreadLocal。

二、包装线程不安全集合
当用多线程操作集合时，对线程不安全的集合进行操作容易破坏集合数据的完整性。
A、<T> Collection<T> synchronizedCollection(Collection<T> c)：返回指定collection对应的线程安全的collection
B、static <T> List<T> synchronizedList(List<T> list)：返回指定List对应的现场安全的List对象
C、static <K, V> Map<K, V> synchronizedMap(Map<K, V> m)：返回指定Map对象对应的现场安全的Map对象
D、static <T> Set<T> synchronizedSet(Set<T> s)：返回指定Set对应的线程安全的Set
E、static <K, V> SortedMap<K, V> synchronizedSortedMap(SortedMap<K, V> m)：返回指定SortedMap对象所对应线程安全的SortedMap对象
F、static <K, V> SortedSet<K, V> synchronizedSortedSet(SortedSet<K, V> m)：返回指定SortedSet对象所对应线程安全的SortedSet 对象
使用线程安全的HashMap对象：
HashMap map = Collections.synchronizedMap(new HashMap());
注意：如果需要把某个集合包装成线程安全的集合，则应该在创建之后立即包装，包装后就是线程安全的HashMap对象了。

三、线程安全的集合
在JDK5后提供了java.util.concurrent包的ConcurrentHashMap、ConcurrentLinkedQueue两个支持并发访问的集合，
它们分别代表了支持并发访问的HashMap和支持并发访问的Queue。默认都支持多线程并发写入，写入操作是线程安全的，读取不必锁定。
这两个集合采用了复杂的算法，他们是永远都锁不住的集合。
当多线程共享访问一个集合时，ConcurrentLinkedQueue最合适不过，Queue不允许为null元素。
Quee实现了多线程的高效访问，多条线程访问ConcurrentLinkedQueue集合是无需等待。
ConcurrentHashMap默认支持16条线程并发访问，当有超过16条线程并发访问就需要等待。
但可以设置concurrentLevel构造方法参数（默认16）来支持更多的线程并发数量。
与HashMap和普通集合不同的是，当我们用迭代器变量ConcurrentHashMap、ConcurrentLinkedQueue时，
如果在迭代器创建后对集合元素的修改是不会在迭代器中做出修改，也不会出现异常。
如果用Collection作为集合对象时，如果对象在创建迭代器后发生变化修改，就会引发ConcurrentModificationException
===============================================================================================================================
java 多线程介绍
1、线程概述
几乎所有的操作系统都支持同时运行多个任务，一个任务通常就是一个程序，每个运行中的程序就是一个进程。
当一个程序运行时，内部可能包含了多个顺序执行流，每个顺序执行流就是一个线程。
2、线程和进程
几乎所有的操作系统都有进程的概念，所有运行中的任务通常对应一条进程。当一个程序进入内存运行，就是一个进程了。
进程是处于运行中的程序，具有一定的独立能力，进程是系统进行资源分配和调度的一个独立单位。
进程特征：
A、独立性：进程是系统中独立存在的实体，可以拥有自己独立的资源，每个进程都拥有自己的私有地址地址。
在没有经过进程本身允许的情况下，一个用户进程不可以访问其他进程地址空间。
B、动态性：进程和程序的区别在于，程序只是一个静态的指令集合，而进程是一个正在系统中活动的指令集合。
在程序中加入了时间概念，进程具有自己的生命周期和各种不同的状态，这些概念是程序不具备的。
C、并发性：多个进程可以在单个处理器上并发执行，多个进程之间不会互相影响。

多线程则扩展了多进程的概念，使得同一个进程可以同时并发处理多个任务。线程也被称为轻量级进程(Lightweight Process)，线程是进程的执行单元。
就像进程在操作系统中的地位一样，线程在程序中是独立、并发执行流。当进程被初始化后，主线程就被创建。对于绝大多数应用程序来说，通常仅要一个主线程，
但我们也可以在该进程内创建多条顺序执行流，这些顺序执行流就是线程，每条线程也互相独立的。
线程是进程的组成部分，一个进程可以拥有多个线程，一个线程必须有一个父进程。线程可以拥有自己的堆、栈、程序计数器、局部变量，但不能拥有系统资源，
它与父进程的其他线程共享该进程所有的全部资源。因为多个线程共享父进程的全部资源。
线程可以完成一定的任务，可与其他线程共享父进程中的变量和部分环境，相互之间协作共同完成进程所要完成的任务。
线程是独立运行的，它并不知道进程中是否还有其他进程存在。线程的执行是抢占方式的，也就是说，当前运行的线程在任何时候都可以被挂起，以便其他线程运行。
一个线程可以创建和撤销另一个线程，同一个进程中的多个线程可以并发执行。
综述：一个程序运行后至少有一个进程，一个进程可以包含多个线程。至少包含一个线程。

3、并发和并行
并发性(concurrency)和并行性(parallel)是两个概念；
并行指在同一时刻，有多条指令（线程）在多个处理器上同时执行；
并发指在同一时刻只能有一个指令（线程）执行，但多个进程指令被快速轮换执行，使得宏观上具有多个进程同时执行的效果。
4、多线程的优势
线程划分尺度小于进程，使得多线程划分的并发性高。进程在执行时有自己独立的单元，多个线程共享内存，从而提高了运行效率。
线程比进程具有更高的性能，这是由于同一个进程中的线程都有共性：多个线程将共享同一个进程的虚拟空间。
线程共性的环境包括：进程代码段、进程共有数据等。线程很容易就利用共性的数据进行通信。
当操作系统创建一个进程时，必须给该进程分别独立的内存空间，并分配大量相关的资源；但创建一个线程则简单得多，因此多线程来实现并发要比多进程实现并发的性能高得多。
多线程优点：
A、进程之间不能共享内存，但线程之间共享内存非常容易。
B、系统创建进程需要为该进程重新分配系统资源，但创建线程则代价要小得多，因此使用线程来实现多任务并发比多进程的效率高。
C、Java语言内置多线程功能支持，而不是单纯的作为底层操作系统的调度方式，从而简化Java的多线程编程。