JUC学习笔记
文章目录
- 锁
- 生产者消费者问题
- 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值对应的线程。