JUC并发编程

JUC并发编程 JUC简介

java.util.concurrent的简称。

JUC核心支持类

NO.	类名称	描述
1	Executor	具体Runnable任务的执行者
2	ExecutorService	线程池故故管理
3	ScheduledExecutorService	线程延迟调度池
4	CompletionService	ExecutorService的扩展，可以获得线程池执行结果
5	Callable	线程执行者，与Runnable的区别在于可以获取线程执行后的结果
6	Future	获取Callable线程执行的结果
7	Semaphore	同步计数信号量
8	ReentrantLock	互斥锁
9	BlockingQueue	阻塞队列
10	CountDownLatch	同步辅助类，实现一组线程池的锁定处理
11	CyclicBarrier	同步辅助类，它允许一组线程相互等待，达到既定线程个数后可以解锁

TimeUnit

枚举类

DAYS
HOURS
MINUTES
SEConDS
MILLISEConDS
MICROSEConDS // 微秒
NANOSEConDS //纳秒

// 将小小时转换为秒
TimeUnit.SECONDS.convert(1L, TimeUnit.HOURS)
    
// 设置休眠时间   1分钟
TimeUnit.MINUTES.sleep(1);

原子操作类

// 基本类型
AtomicInteger、AtomicLong、AtmoicBoolean
// 数组类型
AtomicIntegerArrary、AtomicLongArrary、AtmoicReferenceArray
    其中，compareAndSet方法使用的是==判断是否相等
// 引用类型
AtmoicReference、AtmoicStampedReference、AtomicMarkableReference
    后面两个类解决了ABA问题
// 对象的属性修改类型
AtomicIntegerFieldUpdater、AtomicLongFieldUpdater、AtmoicReferenceFieldUpdater
    更新的属性必须用volatile定义
    
// 并发计算
    JDK1.8之后提供了累加器（DoubleAccumulator、LongAccumulator）与加法器（DoubleAdder、LongAdder）
    // 累加器
    DoubleAccumulator da = new DoubleAccumulator((x, y)->x+y, 1.1); 
	da.accumulate(20); // 最后通过da.get()方法获取结果
	// 加法器
	DoubleAdder da = new DoubleAdder(); // 通过da.sum()方法获取结果

ThreadFactory

// 使用ThreadFactory创建线程
public class MyThreadFactory implements ThreadFactory{
    private static final ThreadFactory INSTANCE = new MyThreadFactory();
    private static final String TITLE = "my-";
    private static final int count = 0;
    private MyThreadFactory() {}
    public static ThreadFactory getInstance() {
        return INSTANCE;
    }
    @Override
    public Thread newThread(Runnable run) {
        return new Thread(run, TITLE + count ++);
    }
}

线程锁 ReentrantLock

互斥锁（独占锁）机制，属于可重用锁

分为公平锁与非公平锁

通过非阻塞队列的方式管理等待的线程

独占锁需考虑性能问题

ReentrantReadWriteLock

读锁是共享锁；写锁只允许一个线程操作；这两种锁互斥，由JVM控制

读线程多的情况下，可能会影响写线程的长时间阻塞

StampedLock

若干个读线程之间不会相互相互影响，但可以保证多个写线程的独占操作

StampedLock分为三种模式：写、读、乐观读，也可以实现锁类型的转换

Condition

获取此接口实例，可以通过Lock接口的newCondition()方法

能够更精细的控制多线程的休眠与唤醒

方法	描述
public void await() throws InterruptedException	线程等待，等价于Object.wait()
public boolean await(long time, TimUnit unit) throws InterruptedException	线程等待指定时间，等价于Object.wait()
public void awaitUninterruptibly()	在唤醒前一直不中断执行
public void signal()	唤醒一个等待线程，等价于Object.notify()
public void signalAll()	唤醒所有等待线程，等价于Object.notifyAll()

LockSupport

提供了一些方法，park()、unpark(Thread thread)等，线程类中的方法，如suspend()、resume()

Semaphore

限制总资源数；可控制公平非公平机制

方法	描述
public Semaphore(int permits)	设置调度资源总数，默认公平机制
public Semaphore(int permits, boolean fair)	设置调度资源总数与公平机制
public void acquire() throws InterruptedException	获取操作许可
public int availablePermits()	判断当前是否有空闲资源
public void release(int permits)	释放资源

CountDownLatch

保证一组子线程全部执行结束后再进行主线程的执行

设置一个线程执行总数，每执行一个就减一

方法	描述
public CountDownLatch(int count)	定义等待子线程总数
public void await() throws InterruptedException	主线程阻塞，等待子线程执行
public void countDown()	子线程执行完后减少等待数量
public long getCount()	获取当前等待数量

CyclicBarrier

达到公共的屏障点才执行，否则就等待

方法	描述
public CyclicBarrier(int parties)	设置屏障点数量
public CyclicBarrier(int parties, Runnable barrierAction)	设置屏障点数量，并设置达到屏障点后要执行的子线程
public int await() throws InterruptedException, BrokenBarrierException	等待线程数量达到屏障点
public int await(long timeout, TimeUnit unit) throws InterruptedException, BrokenBarrierException, TimeoutException	等待线程数量达到屏障点，并设置等待时间
public int getNumberWaiting()	获取等待子线程数量
public void reset()	重置屏障点计数
public boolean isBroken()	查询是否为中断状态
public int getParties()	获取屏障点数量

Exchanger

生产者和消费者模型需要一个公共操作区域进行数据的保存与获取，Exchanger类可实现数据交换

Exchanger exchange = new Exchanger<>();
// 生产者
exchange.exchange("test");
// 消费者
String data = exchange.exchange(null);

CompletableFuture

解决了Future阻塞获或轮询的处理方式的问题

CompletableFuture future = new CompletableFuture();
// 发送命令
future.complete("test");
// 获取到命令
future.get();

并发集合

集合接口	集合类	描述
List	CopyOnWriteArrayList	相当于线程安全的ArrayList，并支持高并发访问
Set	CopyOnWriteArraySet	相当于线程安全的HashSet，基于CopyOnWriteArrayList实现
	ConcurrentSkipListSet	相当于线程安全的TreeSet，基于跳表结构实现，并支持高并发访问
Map	ConcurrentHashMap	相当于线程安全的HashMap，支持高并发访问
	ConcurrentSkipListMap	相当于线程安全的TreeMap，基于跳表结构实现，并支持高并发访问
Queue	ArrayBlockingQueue	基于数组实现的线程安全的有界的阻塞队列
	linkedBlockingQueue	单向链表实现的阻塞队列，支持FIFO处理
	ConcurrentlinkedQueue	单向链表实现的无界队列，支持FIFO处理
Deque	linkedBlockingDeque	双向链表实现的双向并发阻塞队列，支持FIFO、FIFLO处理
	ConcurrentlinkedDeque	双向链表实现的无界队列，支持FIFO、FIFLO处理