#千锋逆战班，周总3.14#

最新推荐文章于 2020-03-22 16:17:06 发布

Fish_Xx

最新推荐文章于 2020-03-22 16:17:06 发布

阅读量165

点赞数

本文链接：https://blog.csdn.net/Fish_Xx/article/details/104865041

版权

高级多线程

线程池

概念：

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

获取线程池：

常用线程池接口和类：（所在包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（）；//这是创建重入锁对象

注意：

使用Lock，需要明确的写上锁和释放锁！
为了避免拿到锁的线程在运行期间出现异常，导致程序终止，没有释放锁！应用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() //获取并移除此队列头部元素，如果没有可用元素，则等待

可以用来解决生产者、消费者问题
阻塞队列的两种实现类：

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

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

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

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

Fish_Xx

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
#千锋逆战班，周总3.14#

高级多线程线程池概念：线程容器，可设定线程分配的数量上限。将预先创建的线程对象存入池中，并重用池中的线程对象。避免频繁的创建和销毁。将任务提交给线程池，由线程池分配线程、运行任务，并在当前线程结束后复用线程。获取线程池：常用线程池接口和类：（所在包java.util.concurrent）Executor：线程池的顶级接口。ExecutotService：线程池接口，可通...
复制链接

扫一扫