高级多线程

线程池

概念：

• 线程容器，可设定线程分配的数量上限。
• 将预先创建的线程对象存入池中，并重用池中的线程对象。
• 避免频繁的创建和销毁。
• 将任务提交给线程池，由线程池分配线程、运行任务，并在当前线程结束后复用线程。

获取线程池：

• 常用线程池接口和类：（所在包java.util.concurrent）
• Executor：线程池的顶级接口。
• ExecutotService：线程池接口，可通过方法submit（Runnable task）提交任务代码。
• Executors工厂类：通过此类可以获得一个线程池。
  通过newFixedThreadPool(int nThread)获取固定数量的线程池。
  通过newCachedThreadPool()获得动态数量的线程池，如不够则创建新的，没有上限（Integer.MAX_VALUE）

Callable接口

	public interface Callable<V>{public V call() throws Exception;}

与Runnable接口类似，也是声明可执行的任务；
但是Callable具有泛型返回值，并且可以声明异常。

Future接口

• 概念：
  异步接收ExceptionService.submit()所返回的状态结果，当中包含了call方法的返回值。

Future<Integer> result1 = es.submit(task1);

• 方法：
  V get() 以阻塞形式等待Future中的异步处理结果（call()的返回值）

Integer value1 = result1.get();

同步与异步：

• 同步:
  形容一次方法调用，同步一旦开始，调用者必须等待该方法返回，才能继续。（单条执行路径）

• 异步:
  形容一次方法调用，异步一旦开始，像是一次消息传递，调用者告知之后立刻返回，二者竞争时间片，并发执行。（多条执行路径）

Lock接口

• 常用方法

void lock(); //获取锁，如锁被占用，则等待。
boolean tryLock()// 尝试获取锁（成功返回true 失败返回false 不阻塞）
void unlock //释放锁

重入锁
ReentrantLock 这是Lock 接口的一个实现类， 声明：

Lock lock =new ReentrantLock（）；//这是创建重入锁对象

• 注意：

1. 使用Lock，需要明确的写上锁和释放锁！
2. 为了避免拿到锁的线程在运行期间出现异常，导致程序终止，没有释放锁！应用try{}finally{}来保证，无论正确执行与否，最终都会释放锁！

读写锁

• ReentrantReadWriteLock
  此类不是Lock接口的实现类，不可用Lock接口指向该类对象
  这是一种支持一写多读的同步锁，读写分离，可分别分配读锁，写锁。
  支持多次分配读锁，使多个读操作可以并发执行
• 声明：

ReentrantReadWriteLock lock=new ReentrantReadWriteLock();
//声明读写锁:读锁与写锁是分离的
ReadLock readLock=lock.readLock();//读锁
WriteLock writelock=lock.writeLock();//写锁

• 互斥规则：
  写-写：互斥 堵塞
  读-写：互斥，堵阻塞写，写阻塞读
  读-读：不互斥，不堵塞

Collections中的工具方法

• 获得线程安全集合的方法：

public static <T> Collection<T> synchronizedCollection(Collection<T> c)
public static <T> List<T> synchronizedList(List<T> list)
public static <T> Set<T> synchronizedSet(Set<T> s)
public static <K,V> Map<K,V> synchronizedMap(Map<K,V> m)
public static <T> SortedSet<T> synchronizedSortedSet(SortedSet<T> s)
public static <K,V> SortedMap<K,V> synchronizedSortedMap(SortedMap<K,V> m)

接口统一、维护性高，但性能没有提升，均以synchronized实现

CopyOnWriteArrayList

• 线程安全的ArrayList，加强版读写分离。（读写不互斥）

• 写有锁，读无锁，读写之间不堵塞，优于独写锁。
  写入时，先copy一个容器副本，再添加信元素，最后替换引用。
  使用方式与ArrayList无异。

• 内部流程：
  写操作 有锁
  每次写入都将底层数组做了一次复制，写的是新数组，完成赋值后，再将新数组替换掉旧数组，每调用一次，底层方法扩容一次。
  读操作 无锁
  读的是写操作完成之前的旧数组，写完之后，才能读到的新数组的新值。

CopyOnWriteArraySet

• 线程安全的Set，底层使用CopyOnWriteArrayList实现。
• 写操作 表面使用的是add方法，底层实际是使用CopyOnWriteArrayList的 addIfAbsent()来判断要插入的新值是否存在。
• 如存在元素，则不添加（扔掉副本）。

ConcurrentHashMap

• 初始容量默认16段（Segment），使用分段锁设计。
• 不对整个Map加锁，而是为每个Segment加锁（锁的是表头对象）。
• 当多个对象存入同一个Segment时，才需要互斥。
• 最理想状态为16个对象分别存入16个Segment，并行数量16。
• 使用方式与HashMap无异。

Queue接口（队列）

• Collection的子接口，表示队列 FIFO（First In First Out）
• 常用方法：
  抛出异常：

boolean add（E e）//顺序添加一个元素（到达上限后，再添加则抛出异常）
E remove（）//获得第一个元素并移除（如果队列没有元素时，则抛异常）
E element（）//获得第一个元素（如果队列没有元素时，则抛异常）

返回特殊值：(推荐使用)

boolean offer（E e）//顺序添加一个元素（到达上线后，在添加则返回false）
E poll（）//获得第一个元素并移除（如果队列没有元素，则返回null）
E keep（） //获得第一个元素但不移除（如果队列没有元素，则返回null）

ConcurrentLinkedQueue

• 线程安全、可高效读写的队列，高并发下性能最好的队列。
• 无锁、CAS比较交换算法，修改的方法包含三个核心参数（V，E，N）。
• V：要更新的变量 E：预期值 N：新值。
• 只有当V==E时，V=N；否则表示已被更新过，则取消当前操作。

BlockingQueue接口（阻塞队列）

• Queue的子接口，阻塞的队列，增加了两个线程状态为无限期等待的方法。
• 方法：

void put(E e) //将指定元素插入此队列中，如果没有可用空间，则等待
E take() //获取并移除此队列头部元素，如果没有可用元素，则等待

• 可以用来解决生产者、消费者问题

• 阻塞队列的两种实现类：

1. ArrayBlockingQueue：
   数组结构实现，有界队列。（手工固定上限）

	BlockingQueue<T> abq=new ArrayBlockingQueue<T>(10);//(队列长度)

2. LinkedBlockingQueue：
   链表结构实现，无界队列。（默认上限Integer.MAX_VALUE）

	BlockingQueue<T> lbq=new LinkedBlockingQueue<T>();