并发编程基础-JUC概述和Lock接口
# 1. JUC概述
# 1.1 JUC简介
JUC就是java.util.concurrent
工具包的简称。这是一个处理线程的工具包,JDK 1.5
开始出现的。
# 1.2 线程和进程
进程(Process) 是计算机中的程序关于某数据集合上的一次运行活动,是系统进行资源分配和调度的基本单位,是操作系统结构的基础。 在当代面向线程设计的计算机结构中,进程是线程的容器。程序是指令、数据及其组织形式的描述,进程是程序的实体。是计算机中的程序关于某数据集合上的一次运行活动,是系统进行资源分配和调度的基本单位,是操作系统结构的基础。程序是指令、数据及其组织形式的描述,进程是程序的实体。
线程(thread) 是操作系统能够进行运算调度的最小单位。它被包含在进程之中,是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流,一个进程中可以并发多个线程,每条线程并行执行不同的任务。
总结来说:
进程:指在系统中正在运行的一个应用程序;程序一旦运行就是进程;进程——资源分配的最小单位。
例如:打开杀毒软件就是一个进程。
线程:系统分配处理器时间资源的基本单元,或者说进程之内独立执行的一个单元执行流。线程——程序执行的最小单位。
例如:杀毒软件中的没想操作即为一个线程。
# 1.3 线程的状态
# 线程状态枚举类
Thread.State
public enum State {
NEW, // 新建
RUNNABLE, // 准备就绪
BLOCKED, // 阻塞
WAITING, // 不见不散
TIMED_WAITING, // 过时不候
TERMINATED; // 终结
}
2
3
4
5
6
7
8
9
10
11
12
13
14
# wait/sleep 的区别
sleep 是 Thread 的静态方法,wait 是 Object 的方法,任何对象实例都能调用。
sleep 不会释放锁,它也不需要占用锁。wait 会释放锁,但调用它的前提是当前线程占有锁(即代码要在 synchronized 中)。
它们都可以被 interrupted 方法中断。
# 1.4 用户线程和守护线程
用户线程: 平时用到的普通线程,自定义线程
守护线程: 运行在后台,是一种特殊的线程,比如垃圾回收
当主线程结束后,用户线程还在运行,JVM 存活
如果没有用户线程,都是守护线程,JVM 结束
# 2. Lock 接口
# 2.1 Synchronized
synchronized
是 Java 中的关键字,是一种同步锁。它修饰的对象有以下几种:
修饰一个代码块,被修饰的代码块称为
同步语句块
,其作用的范围是大括号{}括起来的代码,作用的对象是调用这个代码块的对象;修饰一个方法,被修饰的方法称为
同步方法
,其作用的范围是整个方法,作用的对象是调用这个方法的对象;点击查看
虽然可以使用 synchronized 来定义方法,但 synchronized 并不属于方法定义的一部分,因此,synchronized 关键字不能被继承。如果在父类中的某个方法使用了 synchronized 关键字,而在子类中覆盖了这个方法,在子类中的这个方法默认情况下并不是同步的,而必须显式地在子类的这个方法中加上synchronized 关键字才可以。当然,还可以在子类方法中调用父类中相应的方法,这样虽然子类中的方法不是同步的,但子类调用了父类的同步方法,因此,子类的方法也就相当于同步了。
修改一个静态的方法,其作用的范围是整个静态方法,作用的对象是这个类的所有对象;
修改一个类,其作用的范围是 synchronized 后面括号括起来的部分,作用主的对象是这个类的所有对象。
示例
class Ticket {
// 票数
private int number = 30;
// 操作方法:卖票
public synchronized void sale() {
// 判断:是否有票
if(number > 0) {
System.out.println(Thread.currentThread().getName()+" : 卖出:"+(number--)+" 剩下:"+number);
}
}
}
2
3
4
5
6
7
8
9
10
11
如果一个代码块被 synchronized 修饰了,当一个线程获取了对应的锁,并执行该代码块时,其他线程便只能一直等待,等待获取锁的线程释放锁,而这里获取锁的线程释放锁只会有两种情况:
获取锁的线程执行完了该代码块,然后线程释放对锁的占有;
线程执行发生异常,此时 JVM 会让线程自动释放锁。
那么如果这个获取锁的线程由于要等待 IO 或者其他原因(比如调用 sleep方法)被阻塞了,但是又没有释放锁,其他线程便只能干巴巴地等待,试想一下,这多么影响程序执行效率。
因此就需要有一种机制可以不让等待的线程一直无期限地等待下去(比如只等待一定的时间或者能够响应中断),通过 Lock 就可以办到。
# 2.2 什么是 Lock (opens new window)
Lock
锁实现提供了比使用同步方法和语句可以获得的更广泛的锁操作。它们允许更灵活的结构,可能具有非常不同的属性,并且可能支持多个关联的条件对象。Lock
提供了比synchronized
更多的功能。
# Lock接口 🐱
public interface Lock {
/**
* 上锁
*/
void lock();
void lockInterruptibly() throws InterruptedException;
boolean tryLock();
boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
/**
* 释放锁
*/
void unlock();
Condition newCondition();
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# Condition
关键字 synchronized 与 wait()/notify()这两个方法一起使用可以实现等待/通知模式, Lock 锁的 newContition()方法返回 Condition 对象,Condition 类也可以实现等待/通知模式。
用 notify()通知时,JVM 会随机唤醒某个等待的线程, 使用 Condition 类可以进行选择性通知, Condition 比较常用的两个方法:
await()会使当前线程等待,同时会释放锁,当其他线程调用 signal()时,线程会重新获得锁并继续执行。
signal()用于唤醒一个等待的线程。
注意:在调用 Condition 的 await()/signal()方法前,也需要线程持有相关的 Lock 锁,调用 await()后线程会释放这个锁,在 singal()调用后会从当前Condition 对象的等待队列中,唤醒 一个线程,唤醒的线程尝试获得锁, 一旦获得锁成功就继续执行。
# ReadWriteLock
ReadWriteLock是一个接口,在它里面只定义了两个方法:
public interface ReadWriteLock {
/**
* 写锁
*/
Lock readLock();
/**
* 读锁
*/
Lock writeLock();
}
2
3
4
5
6
7
8
9
10
11
一个用来获取读锁,一个用来获取写锁。也就是说将文件的读写操作分开,分成 2 个锁来分配给线程,从而使得多个线程可以同时进行读操作。
# ReentrantLock 😄
ReentrantLock:可重入锁
ReentrantLock 是唯一实现了 Lock 接口的类,并且 ReentrantLock 提供了更多的方法。
示例
class LTicket {
// 票数量
private int number = 30;
// 1. 创建可重入锁
private final ReentrantLock lock = new ReentrantLock();
//卖票方法
public void sale() {
// 2. 上锁
lock.lock();
try {
// 判断是否有票
if (number > 0) {
System.out.println(Thread.currentThread().getName() + " :卖出" + (number--) + " 剩余:" + number);
}
} finally {
// 3. 解锁
lock.unlock();
}
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# 2.3 Lock 与的 Synchronized 区别 😈
Lock 是一个接口
,而synchronized 是 Java 中的关键字
,synchronized 是内置的语言实现;-- synchronized 在发生异常时,会自动释放线程占有的锁,因此不会导致死锁现象发生;而
Lock 在发生异常时,如果没有主动通过 unLock()去释放锁,则很可能造成死锁现象,因此使用 Lock 时需要在 finally 块中释放锁
; - Lock 可以
让等待锁的线程响应中断
,而 synchronized 却不行,使用synchronized 时,等待的线程会一直等待下去,不能够响应中断; - 通过Lock可以知道
有没有成功获取锁
,而 synchronized 却无法办到。 - Lock 可以
提高多个线程进行读操作的效率
。