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<N;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<N;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<Integer> 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