一、 Lock 锁
java.util.concurrent.locks.Lock
为什么有了synchronized,还需要Lock呢？
- 使用方式更灵活
- 性能开销小
1.1 ReentrantLock
简单示例：
public class TestLock {
private Lock lock=new ReentrantLock();
private int value;
public void add(){
try {
lock.lock();
value++;
} finally {
lock.unlock();
}
}
}
ReentrantLock：可重入锁
new ReentrantLock(true):可重入锁+公平锁
可重入锁：某个线程已经获得某个锁，可以再次获取锁而不会出现死锁。 ReentrantLock和synchronized都是可重入锁。
公平锁：先排队的先获得锁。
可重入锁的示例：
public class TestLock {
private Lock lock=new ReentrantLock();
private int value;
public void add(){
try {
lock.lock();
value++;
//已经获取了锁，再进入也要获取锁的print方法，不会产生死锁
print();
} finally {
lock.unlock();
}
}
public void print(){
try {
lock.lock();
System.out.println("打印内容");
} finally {
lock.unlock();
}
}
public static void main(String[] args) {
new TestLock().add();
}
}
1.2 ReentrantReadWriteLock 读写锁
读写锁示例：
public class TestLock {
private int sum;
private ReadWriteLock lock=new ReentrantReadWriteLock(true);
public int incrAndGet(){
try {
lock.writeLock().lock();
sum++;
return sum;
} finally {
lock.writeLock().unlock();
}
}
public int getSum(){
try {
lock.readLock().lock();
return sum;
} finally {
lock.readLock().unlock();
}
}
}
读读不互斥，读写互斥，写写互斥
适用于读多写少的场景。
读为什么要加锁呢？
答：避免读的时候去写。
1.3 Condition的用法
使用Condition实现了生产-消费的案例
public class TestLock {
private int sum;
Lock lock = new ReentrantLock();
Condition notFull = lock.newCondition();
Condition notEmpty=lock.newCondition();
public void consumer() throws InterruptedException {
try {
lock.lock();
while (sum<=0){
notEmpty.await();
}
sum--;
System.out.println("消费者："+sum);
notFull.signal();
} finally {
lock.unlock();
}
}
public void producer() throws InterruptedException {
try {
lock.lock();
while (sum>=20){
notFull.await();
}
sum++;
System.out.println("生产者："+sum);
notEmpty.signal();
} finally {
lock.unlock();
}
}
public static void main(String[] args) {
TestLock testLock=new TestLock();
new Thread(new Runnable() {
@Override
public void run() {
try {
while (true){
testLock.consumer();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
try {
while (true){
testLock.producer();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
}
}
1.4 LockSupport 锁当前线程
使用示例：
public class TestThread {
public static void main(String[] args) throws InterruptedException {
ChildThread childThread = new ChildThread(Thread.currentThread());
childThread.start();
LockSupport.park();
System.out.println("主线程结束");
}
private static class ChildThread extends Thread{
private Thread thread;
public ChildThread(Thread thread) {
this.thread = thread;
}
@Override
public void run() {
try {
Thread.sleep(3000);
System.out.println("模拟一些初始化操作");
LockSupport.unpark(thread);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
用锁的最佳实践
- 永远只在更新对象的成员变量时加锁
- 永远只在访问可变的成员变量时加锁
- 永远不再调用其他对象的方法时加锁
二、并发原子类
并发原子类所在的包：java.util.concurrent.atomic
使用示例：
public class TestLock {
private AtomicInteger atomicInteger=new AtomicInteger();
public int add(){
return atomicInteger.incrementAndGet();
}
public int get(){
return atomicInteger.get();
}
}
整个AtomicInteger的实现是无锁的。
实现原理：
- volatile保证读写操作都可见
- 使用CAS指令，通过自旋重试保证写入
- CAS是基于Unsafe的API Compare-And-Swap
- CPU 硬件指令支持 ：CAS指令
LongAdder 对AtomicLong的改进：
分段思想。
三、并发工具类
我们已经有了锁、有了并发原子类，为什么我们还需要并发工具类呢？
思考以下场景：有一个方法，用10个线程来分别都执行，但是同时只能有4个在执行。用锁的方式就不好实现。所以JDK给我们提供了以下的并发工具类。
3.1 Semaphore 信号量
应用场景：同一时间控制并发线程数。
public class TestLock {
//声明4个permits(许可证)的信号量
Semaphore semaphore = new Semaphore(4);
public static void main(String[] args) {
TestLock testLock = new TestLock();
for (int i = 0; i < 10; i++) {
new Thread(new Runnable() {
@Override
public void run() {
try {
testLock.test();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
}
}
public void test() throws InterruptedException {
//拿到一个permits（许可证），也可以带参，一个线程拿两个，如：semaphore.acquire(2);
semaphore.acquire();
System.out.println(Thread.currentThread().getName() + "在工作");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
//释放一个permits
semaphore.release();
}
}
}
3.2 CountDownLatch 闭锁
应用场景：Master线程等待所有Worker线程把任务执行完。
示例：公司有5个人，每个人都完成了手头的工作，老板才下班。
public class TestLock2 {
CountDownLatch countDownLatch=new CountDownLatch(5);
public static void main(String[] args) throws InterruptedException {
TestLock2 testLock = new TestLock2();
for (int i = 0; i < 5; i++) {
new Thread(new Runnable() {
@Override
public void run() {
testLock.test();
}
}).start();
}
testLock.countDownLatch.await();
System.out.println("大家都工作完了，老板（监工）可以下班了");
}
public void test() {
System.out.println(Thread.currentThread().getName() + "在工作");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
countDownLatch.countDown();
System.out.println(Thread.currentThread().getName() + "工作完了");
}
}
}
相当于CountDownLatch有一个计数器，调用了await方法后等待在那里了，每调用countDown方法就减一，只有当计数器减为0了，await才被唤醒。
3.3 CyclicBarrier 栅栏
场景：任务执行到一定阶段，等其他任务对齐
在作用上很类似CountDownLatch，只是使用的方法不一样。
示例：
public class TestLock2 {
CyclicBarrier cyclicBarrier=new CyclicBarrier(5);
public static void main(String[] args) throws InterruptedException {
TestLock2 testLock = new TestLock2();
for (int i = 0; i < 5; i++) {
new Thread(new Runnable() {
@Override
public void run() {
testLock.test();
}
}).start();
}
}
public void test() {
System.out.println(Thread.currentThread().getName() + "在工作");
try {
int i = new Random().nextInt(10);
TimeUnit.SECONDS.sleep(i);
System.out.println(Thread.currentThread().getName() + "工作完了");
cyclicBarrier.await();
System.out.println("大家都工作完了，老板（监工）可以下班了");
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
}
}
CyclicBarrier没有countDown方法，而是都阻塞到await那里，等阻塞的个数达到，就可以放行。
3.4 AQS 同步队列器
AQS是AbstractQueuedSynchronizer的缩写，它是构建锁或其他组件的基础。如：CountDownLatch、Semaphore、ReentrantLock。
里面有两种资源共享方式：独占|共享。 独占的实现如ReentrantLock,共享的实现如 Semaphore 。子类负责实现公平锁或者非公平锁。
以ReentrantLock为例，里面有一个state变量，如果state为0，则表示未锁定，调用tryAcquire方法独占锁，并将state+1，此后其他线程来就不能占用了，放入队列里去等着。如果还是当前线程调用，那么他是可以再获得锁的，只是state还要累加。（可重入的概念）但是要注意，获得多少次就要释放多少次才行。
