JUC学习随记

开始并发学习

java能开启线程吗

不能，start方法的源码里，是去调用本地native的start（jdk1.8源码中是这个）方法，该方法不是java做的。

wait和sleep的区别

1.包来源不同
wait是来自java.lang.Object类的。
sleep是来自java.lang.Thread的。
==我们可以通过 JUC包下的TimeUtil这个工具类来使用sleep方法。
2.关于锁的释放
wait会释放锁。
sleep不会释放锁，抱着锁睡着了，抱的太紧了
3.使用范围不一样
wait必须在同步代码块中使用
sleep可以在任何地方
4.是否需要捕获异常
wait需要捕获异常
sleep需要捕获异常

一般怎么写线程

不建议直接拿一个类去继承Implement。
一般只是拿一个类做资源类，里面专门放一些涉及到多线程的操作。
然后可以使用 “那么大” 表达式来使用，使用方式：（参数）->{ 方法体}

Lock加锁三步

1、创建锁，new ReentrantLock(boolean fari) 默认非公平锁
2、加锁 lock()
3、释放锁 unlock()

Synchronized和Lock的区别

1、最明显的，Synchronized是一个关键字，Lock是一个类。
2、synchronized不可以判断锁的状态，Lock可以通过tryLock()
3、synchronized可以自动释放锁，而lock不可以，要手动释放
4、synchronized获得锁后，只能等待，但lock不一定会等待
5、synchronized可重入锁，不可以中断，非公平，Lock可重入锁，可以自己设置公平还是非公平，默认false非公平
6、synchronized是适合锁少量的情况，Lock可以适合大量的同步代码

锁的是谁的问题

如果是一个方法加了锁，那么调用这个锁的对象被锁住了。而如果是同一个对象想去调用其他的东西，就不行了，因为这个对象还在上一个方法里被锁着。
但如果这个方法还是一个静态方法，那么这个锁就是一个类锁。因为静态方法在类创建的时候就加载了。所以不管怎么样，类只有一个。不管你弄多少对象，都得等待执行。我觉得这也是为了静态方法直接用类名调用即可，不建议使用对象调用。

虚假唤醒的问题

在wait和notify的操作过程中，对于执行条件的语句要选用while，而不是if。避免在高并发的情况下，出现虚假唤醒

在集合类中，怎么解决不安全的问题

比如对于ArrayList集合，它其实在多线程下是一个不安全的集合，会报一个集合类并发下编译错误。对于ArrayList集合的替代方法有三个吧。
1、我们可以直接使用vector来代替，理由是它加了synchronized锁，但也同样因为加了synchronized锁的原因，导致速度缓慢。
2、在Collection包下，提供了集合安全的做法，我们用Collection.Synchronized来修饰ArrayList
3、在JUC包下，提供了集合安全的做法，对于ArrayList使用一个读写锁。CopyOnWriteArrayList (cow)，在写入的时候复制一份，然后在覆盖回去。这个类用的锁其实已经是Lock锁了，而不是synchronized锁，所以性能肯定要比vector好一点。（这个包下还有其他的，比如CopyOnWriteArraySet，ConcurrentHashMap等）

Callable接口

Callable有一个泛型，这个泛型的数据类型取决于call方法return的数据类型。
新写一个对象继承Callable，实现Callable接口，然后重写call方法，把new出来的该类对象作为值传入FutureTask中，通过Thread的启动方法启动该FutureTask对象，通过FutureTask的get方法，就能获取到返回值。

CountDownLatch

减法计数器。new对象的时候传入初始值（>0）使用该类本身的CountDown方法，线程每执行一次就执行一次CountDown。
可以使用await方法，等待执行完

CyclicBarrier

加法计数器，等线程执行好后，就执行++的操作，如果达到临界值，那么就触发CyclicBarrier的方法体。
同样要使用await方法

CountDownLatch和CyclicBarrier区别

1.countDownLatch是一个计数器，线程完成一个记录一个，计数器递减，只能只用一次
2.CyclicBarrier的计数器更像一个阀门，需要所有线程都到达，然后继续执行，计数器递增，提供reset功能，可以多次使用

Semaphore

Semaphore可以规划信号量的大小。有两个方法，一个acquire，一个release。acquire代表占用资源。你可以把信号量想象成停车位，执行acquire，则代表找出一个空闲的车位去停车，如果车位满了，则线程等待。或者就是通过release释放车位。

读写锁

对于ReentrantReadWriteLock，可重录读写锁，是一个比Lock更细粒度的锁，用法同lock基本一致。控制写的时候只能写，读的时候只能读。读那边如果不加读锁，那么就有可能被写锁插队，一旦被写锁插队，那么就可能发生脏读。

阻塞队列

BlockingQueue是一个接口，继承Queue。与其同级的还有deque（双端队列，可以从两头取），AbstractQueue。

对于阻塞队列，我们有四种的情况可以讨论。不同的方法，对于异常的解决是不一样的

返回方式	直接抛出异常	不抛出异常，返回结果来表示情况	不会抛出错误，阻塞，会一直等待，导致程序卡死在那	超时等待，如果超时还不能存和取，则放弃阻塞
进队	add	offer	put	offer(值,时长,时间单位)
出队	remove	poll	take	poll(值,时长,时间单位)
判断队首	element	peek	-	-

同步队列

SynchronizedQueue，是一个同步队列，是一个实现了BlockingQueue的类，同步队列中只能有一个元素，得等待元素离开，才能再放元素进去。

线程池

池化技术。
我们接触过很多的池化技术，比如线程池，对象池，连接池，内存池。
对于线程池的学习，一定要掌握3个方法，7个参数，4种拒绝策略
1、三个方法

# 阿里巴巴开发手册规范，提醒我们，最好不要用executor来创建，而是使用ThreadPoolExecutor。
1. newSingleThreadExecutor   # 单一线程
2. newFixedThreadPool         # 固定大小线程
3. newCachedThreadPool   # 可伸缩线程大小

2、七大参数
从上至下依次为

1.核心线程数
2.最大线程数
3.生存时间
4.时间单位
5.阻塞队列大小
6.创建线程使用的工厂
7.拒绝策略

3、四大拒绝策略
从上至下依次是

1.AbortPolicy      总是抛出异常
2.CallerRunsPolicy     将任务丢给启动线程池的线程去执行。
3.DiscardOldestPolicy  让最早进入阻塞队列的离开，然后自己进去排队
4.DiscardPolicy    直接丢弃任务

函数式接口及Stream流式计算

函数式接口及Stream流式计算

ForkJoin

从JDK1.7开始，Java提供ForkJoin框架用于并行执行任务，它的思想就是讲一个大任务分割成若干小任务，最终汇总每个小任务的结果得到这个大任务的结果。
特点：分化问题，双端队列，提高CPU利用率，线程多，执行速度快

Fork/Join框架基本使用

比如对于求和，有什么快速一些的办法
1.直接求和
2.用ForkJoin
3.Stream流式计算

异步回调

利用CompletaFuture（jdk1.8的新特性，提供了异步编程）。（可带返回值，可不带）
async（不带返回值） supplyAsync（带返回值）
whencomplate（一个返回值，一个错误信息）
exceptionally（错误信息返回）

JMM

工作内存和主内存
工作内存其实只是一个概念，真正的线程工作内存其实如下，上面的工作内存实际指的是下面的一二级缓存或者CPU寄存器

将上面的工作内存抽象成概念，则为下图
8个操作，成对进行。
为了保证内存的可见性，引入了Volatile关键字

Volatile

• 可见性。
  对一个volatile变量的读，总是能看到（任意线程）对这个volatile变量最后的写入。
• 原子性：
  对任意单个volatile变量的读/写具有原子性，但类似于volatile++这种复合操作不具有原子性。
• 禁止指令重排
  利用内存屏障的方式。会在Volatile字段的读写操作前后加上屏障。