java高并发总结-常用于面试复习
可以直接在关注公众号，查看相关文章，博主总结了一些关于java高级工程师的面试知识点
定义：
独占锁是一种悲观保守的加锁策略，它避免了读/读冲突，如果某个只读线程获取锁，则其他读线程都只能等待，这种情况下就限制了不必要的并发性，因为读操作并不会影响数据的一致性。
共享锁则是一种乐观锁，它放宽了加锁策略，允许多个执行读操作的线程同时访问共享资源。
分类：
独占锁：
ReentrantLock， ReentrantReadWriteLock.WriteLock
共享锁
：ReentrantReadWriteLock.ReadLock，CyclicBarrier， CountDownLatch和Semaphore都是共享锁
其他：
wait(), notify()
@hxx，对应Contition的
await
和
signal
前者是object，在代码中用锁对象即可调用，后者是一个即可，必须使用ReentrantLock生成
final Lock lock = new ReentrantLock();
final Condition notFull = lock.newCondition();
final Condition notEmpty = lock.newCondition();
Synchronized
ReentrantLock是Synchronized一种更高级的改进
1： 更加面向对象，性能更好
2： 提供了更多机制，
比如时间锁等候，可中断锁等候，锁投票等
3： ReentrantLock提供了可轮询的锁请求，提供
tryLock()方法
；而synchronized则会一直阻塞等待
Lock lock = ...;
if (lock.tryLock()) {
try {
// manipulate protected state
} finally {
lock.unlock();
}
} else {
// 资源正在被别人写，先做别的事情吧，比如说打印一行日志
}
注意事项
：
除了Synchronized自动走出锁范围，其余占有了锁，一定要记得释放锁，可以在finally中释放!!!!
公平参数，默认都是关闭的，所以不要以为等的时间越长就能更大几率获得锁！公平和非公平对应着：公平锁和非公平锁（
Sync
类的两个子类），非公平锁无视等待队列，直接上来就是抢！
java实现锁的底层都是使用
Sync类，
private
final
Sync sync;
是继承了AbstractQueuedSynchronizer的内部抽象类，主要由它负责实现锁的功能。关于 AbstractQueuedSynchronizer 只要知道它内部存在一个获取锁的等待队列及其互斥锁状态下的int状态位（0当前没有线程持有该锁、n存在某线程重入锁n次）即可，该状态位也可用于其它诸如共享锁、信号量等功能。
----------------------------------------
Demo code
：
1:
CountDownLatch
用于n个线程等待其余M个线程结束
,
类位于java.util.concurrent包下
代码：
CountDownLatch doneSignal = new CountDownLatch(3); // 定义了计数器为3.表示有3个线程结束即可！
for(int i=0; i<5; i++)
new InnerThread().start(); //
m个线程，InnerThread的run方法
末尾
中写了
doneSignal .countDown(); 必须手动减
doneSignal.await();
// 阻塞，直到3个线程结束
//
await(
long
timeout, TimeUnit unit)
throws
InterruptedException { }; 这个就可以实现超时功能
2:
CyclicBarrier
java.util.concurrent包
，
实现 M 个线程在barrier栅栏处互相等待
，可以重用状态（所以叫cycli），1的计数器只能减不能重新赋值！
代码：
CyclicBarrier barrier = new CyclicBarrier(N);//
N个线程互相等
for(int i=0;i
new Writer(barrier).start(); // Writer
的run方法
需要M个线程一起完成的点
中写了barrier.await
();
3：
Semaphore
java.util.concurrent包
，用于限制最多M个线程同时并发
代码：
int N = 8;
//工人数
Semaphore semaphore = new Semaphore(5);
//机器数目， 限制了最多5个并发， 默认是不公平的构造可以加true
for(int i=0;i
new Worker(i,semaphore).start();
@Override
public void run() {
try {
semaphore.acquire();
// 拿凭证，总共5张凭证，没拿到会阻塞， 不想阻塞可用
tryAcquire
System.out.println("工人"+this.num+"占用一个机器在生产...");
Thread.sleep(2000);
System.out.println("工人"+this.num+"释放出机器");
semaphore.release();
// 释放凭证
} catch (InterruptedException e) {
e.printStackTrace();
}
}
4：
ReentrantLock
java.util.concurrent包
，用于实现同步功能，与synchronized相似但是面向对象更灵活
ReentrantLock takeLock = new ReentrantLock();
// 获取锁
takeLock.lock();
try {
// 业务逻辑
} finally {
// 释放锁
takeLock.unlock();
}
5：
ReentrantReadWriteLock
4是其父类，根据名字可以看到这个类区分了读写锁，与4的优势是
线程大多在数据结构中读取数据而少有修改时
这个就有用了。
读写锁要实现的功能是三点
：
多个读互相不干扰
；多个写操作必须独占锁；读和写操作要上锁
！（@hxx第一个分号我我为什么要用黑色，因为这就是读写锁出现的意义，提升了读的性能，不然就用4了）
如何实现的呢？ 看先代码！
以下这段代码来自jdk文档中demo，写的非常好！！
class CachedData { Object data; volatile boolean cacheValid; ReentrantReadWriteLock rwl = new ReentrantReadWriteLock(); void processCachedData() { rwl.readLock().lock();
//
step1
@hxx 任何人都可以读数据,因为没人写，提高性能 if (!cacheValid) {
// @hxx 如果有缓存了，就不用去load数据库写缓存了，相当于if(cache.get(key) == null)
// Must release read lock before acquiring write lock rwl.readLock().unlock();
// @hxx 为什么 拿“写锁” 前要释放掉 “读锁”？？ 要判断没有人拿 “读锁” 才可以写吗，是这样实现读写互斥的吗？ 如果是，那么我在这里不释放，是不是就违背了机制，try后，确实是的 rwl.writeLock().lock();
// @hxx 从这里开始，保证一次只有一个线程进来啦
begin
！！
// Recheck state because another thread might have acquired // write lock and changed state before we did. if (!cacheValid) { data = ... cacheValid = true; } // Downgrade by acquiring read lock before releasing write lock
// @hxx，我先那个读锁，哈哈， 在我释放读锁之前，谁也别想拿写锁，因为写锁拿到的前提是没有人拿读锁 rwl.readLock().lock(); rwl.writeLock().unlock();
// Unlock write, still hold read
// @hxx 从这里开始，保证一次只有一个线程进来啦
end
！！ } use(data);
//
step2
@hxx 我在读数据不怕别人写，真的爽！ rwl.readLock().unlock();
// @hxx 现在我释放了读锁，去拿写锁吧！ } }
ps： 上面代码。缓存一旦初始化成功后，后续的逻辑就只会走
step1 +
step2 了，就只有读锁共享了！
6： ReentrantReadWriteLock.ReadLock 和ReentrantReadWriteLock.WriteLock
看jdk文档里面。以为又是一个新的东西，其实就是5中代码
ReentrantReadWriteLock.writeLock() 返回的对象
ReentrantReadWriteLock.readLock() 返回的对象
略过
7： wait(), notify()
java.lang.Object 的方法
查看该笔记
https://note.youdao.com/web/#/file/WEB82c69340fd16ecd931ee5920c6dc88cf/note/WEB384aff600e287fc0656f08883ad894d4/
8： Condition接口
（需要与
ReentrantLock
配合使用）
条件变量很大一个程度上是为了解决Object.wait/notify/notifyAll难以使用的问题，
@hxx也就是消费者生产者代码中判断队列是否满，是否空的条件！
代码如下：
final Lock lock = new ReentrantLock();
final Condition notFull = lock.newCondition();
final Condition notEmpty = lock.newCondition();
private Queue buffer = new LinkedList<>();
int max = 100;
int putptr, takeptr, count;
public void put(Object x) throws InterruptedException {
lock.lock();
// 先拿锁
try {
while (max == buffer.size())
notFull.await();
// 不满，则可以放
buffer.add(1);
// 提醒可以取
notEmpty.signal();
} finally {
// 记得释放锁
lock.unlock();
}
}
public Object take() throws InterruptedException {
lock.lock();
try {
while (count == 0)
notEmpty.await();
//不空， 可以取
int x= buffer.poll();
// 提醒可放
notFull.signal();
return x;
} finally {
lock.unlock();
}
}
8： synchronized