文章目录
- 锁
- 生产者消费者问题
- 8锁现象
- 集合类不安全
- Callable
- 创建线程的三种方式
- 常用辅助类
- CountDownLatch
- Cyclibarrier
- Samphore
本篇博客是之前学习JUC时记录的内容，对于并发编程知识只是浅浅谈及，并不深入。也算是给自己开新坑。建一个JUC的专栏，后续学习有地方记录。
锁
并发：多个线程操作同一个资源类，把资源丢入线程。
- 传统Synchronized，本质是锁加队列。
- lock：是一个接口。
lock的实现类有：
- ReentrantLock（可重入锁）
- ReentrantReadWriteLock.ReadLock（可重入读写锁中的读锁）
- ReentrantReadWriteLock.WriteLock（可重入读写锁中的写锁）
ReentrantLock默认实现是非公平锁，可以创建时指定为公平锁。
public ReentrantLock() {
sync = new NonfairSync();
}
/**
* Creates an instance of {@code ReentrantLock} with the
* given fairness policy.
*
* @param fair {@code true} if this lock should use a fair ordering policy
*/
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
公平锁：按照先来后到的顺序依次执行，有一定的次序。
非公平锁：与公平锁相反，不按照一定的次序执行。
synchronized与lock的区别：
- Synchronized 是Java的关键字，Lock是Java的接口，对应有接口的实现类ReentrantLock、ReentrantReadWriteLock。
- Synchronized 不可以判断获取锁的状态，Lock可以判断获取锁的状态。
- Synchronized 会自动释放锁，Lock需要手动释放锁，不释放则死锁。
- Synchronized 线程1（获得锁，阻塞），线程2（等待，死等），Lock锁不一定会等待下去，基于内部的
tryLock()函数实现。 - Synchronized 可重入锁，不可以中断的，非公平的，Lock可重入锁，可以判断锁，非公平（可以自己设置）
- Synchronized 适合锁少量的代码同步问题，Lock适合锁大量的同步代码。
生产者消费者问题
生产者和消费者的Synchronized版：
基本步骤：判断等待、执行业务、唤醒（通知）
public class Demo1 {
public static void main(String[] args) {
// 创建资源
Resources resources = new Resources();
// 执行并发，创建线程，将资源放置到线程中
new Thread(()->{
for (int i = 0; i < 10; i++) {
try {
resources.increment();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"Producer").start();
new Thread(()->{
for (int i = 0; i < 10; i++) {
try {
resources.decrement();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"Consumer").start();
}
}
class Resources{
private int num = 0;
public synchronized void increment() throws InterruptedException {
// 判断等待
while(num != 0){
this.wait();
}
// 执行业务
++num;
System.out.println(Thread.currentThread().getName() + "---" + num);
// 通知其他线程
this.notifyAll();
}
public synchronized void decrement() throws InterruptedException {
// 判断等待
while(num == 0){
this.wait();
}
// 执行业务
--num;
System.out.println(Thread.currentThread().getName() + "---" + num);
// 通知其他线程
this.notifyAll();
}
}
上面判断条件能否改为if，不能：
if只会判断一次，随后释放锁，另一个线程获得锁后进行if判断，同时处于等待，两个线程均处于等待状态，随后其他线程执行唤醒操作，进入if里面wait的两个线程都执行后面的业务逻辑。if只在进入的时候判断一次，唤醒后if里面存在多个线程此时也不会判断。
if只判断一次，在等待的时候另一个线程修改了数据，那么wait后就不会进行If判断。
使用while判断当多个生产者进入循环并执行等待操作，随后其他线程执行唤醒操作后，生产者仍然会再次进行判断num!=0进而决定是否执行后续业务代码，防止其他生产者更改num后当前生产者仍然执行++num操作。
生产者和消费者的Lock版：
public class Demo2 {
public static void main(String[] args) {
// 创建资源
Resources2 resources2 = new Resources2();
// 执行并发，创建线程，将资源放置到线程中
new Thread(() -> {
for (int i = 0; i < 10; i++) {
try {
resources2.increment();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, "Producer1").start();
new Thread(() -> {
for (int i = 0; i < 10; i++) {
try {
resources2.increment();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, "Producer2").start();
new Thread(() -> {
for (int i = 0; i < 10; i++) {
try {
resources2.increment();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, "Producer3").start();
new Thread(() -> {
for (int i = 0; i < 100; i++) {
try {
resources2.decrement();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, "Consumer").start();
}
}
class Resources2{
private int num = 0;
// 创建锁
Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();
public void increment() throws InterruptedException {
// 加锁
lock.lock();
try {
// 判断等待
while(num != 0){
condition.await();
}
// 执行业务
++num;
System.out.println(Thread.currentThread().getName() + "---" + num);
// 通知其他线程
condition.signalAll();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
// 解锁
lock.unlock();
}
}
public void decrement() throws InterruptedException {
// 加锁
lock.lock();
try {
// 判断等待
while(num == 0){
condition.await();
}
// 执行业务
--num;
System.out.println(Thread.currentThread().getName() + "---" + num);
// 通知其他线程
condition.signalAll();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
// 解锁
lock.unlock();
}
}
}
使用condition实现的精准唤醒和通知线程：
package condition;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* Condition的精准唤醒
*/
public class Demo1 {
public static void main(String[] args) {
// 创建资源
Resource3 resource3 = new Resource3();
// 创建线程，将资源传给线程，执行对应的并发操作
new Thread(()->{
for (int i =0; i < 10; i++) {
try {
resource3.printA();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"A").start();
new Thread(()->{
for (int i =0; i < 10; i++) {
try {
resource3.printB();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"B").start();
new Thread(()->{
for (int i =0; i < 10; i++) {
try {
resource3.printC();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"C").start();
}
}
class Resource3{
// 创建锁
private Lock lock = new ReentrantLock();
private Condition condition1 = lock.newCondition();
private Condition condition2 = lock.newCondition();
private Condition condition3 = lock.newCondition();
private int num = 1;
public void printA() throws InterruptedException {
// 加锁
lock.lock();
try {
while(num != 1){
condition1.await();
}
System.out.println(Thread.currentThread().getName() + ":num=" + num + "AAAAAA");
num = 2;
// 唤醒下一个
condition2.signal();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void printB() throws InterruptedException {
// 加锁
lock.lock();
try {
while(num != 2){
condition2.await();
}
System.out.println(Thread.currentThread().getName() + ":num=" + num + "BBBBBB");
num = 3;
// 唤醒下一个
condition3.signal();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void printC() throws InterruptedException {
// 加锁
lock.lock();
try {
while(num != 3){
condition3.await();
}
System.out.println(Thread.currentThread().getName() + ":num=" + num + "CCCCCC");
num = 1;
// 唤醒下一个
condition1.signal();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
上面代码的逻辑是使用Condition唤醒对应的线程，但本身存在一个很大的漏洞，只使用一个Condition仍可以实现上面的流程，由于有个控制变量num的存在，唤醒所有线程后也只会执行num值对应的线程。