7.线程锁基础
(1)死锁
- 多个线程各自占有一些共享资源,并且互相等待其他线程占有的资源才能运行,而导致两个或者多个线程都在等待对方释放资源,都停止执行的情形。某一个同步代码块同时拥有
" 两个以上对象的锁 "
时,就可能会发生"死锁"的问题。
代码实现
// 死锁:多个线程互相抱着对方需要的资源,然后形成僵持
public class DeadLock {
public static void main(String[] args) {
Makeup g1 = new Makeup(0,"小黑");
Makeup g2 = new Makeup(1,"小白");
g1.start();
g2.start();
}
}
// 口红
class LipStick {
}
// 镜子
class Mirror {
}
// 化妆
class Makeup extends Thread{
// 为什么要定义成static:需要的资源只有一份,需要用static来保证
static LipStick lipStick = new LipStick();
static Mirror mirror = new Mirror();
int choice;//选择
String name;//化妆的人
// 有了自定义的字段必然有构造器【构造器的方法名称一定与该类的方法名称一样】
Makeup(int choice,String name) {
this.choice = choice;
this.name = name;
}
@Override
public void run() {
// 化妆1
/*try {
makeup(choice,name);
} catch (InterruptedException e) {
e.printStackTrace();
}*/
// 化妆2
try {
makeup(name,choice);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 互相持有对方的锁,就是需要拿到对方的资源
// 化妆形成死锁情况
private void makeup(int choice,String name) throws InterruptedException {
if (choice == 0) {
synchronized (lipStick) {// 先锁定口红
System.out.println(name + ">>>>使用口红中");
Thread.sleep(1000);
synchronized (mirror) {// 口红没用完的情况下,加上使用镜子
System.out.println(name + ">>>>使用口红的同时使用镜子!");
}
}
} else {
synchronized (mirror) {// 先锁定镜子
System.out.println(name + ">>>>使用镜子中");
synchronized (lipStick) {// 镜子没用完的情况下,加上使用口红
System.out.println(name + ">>>>使用镜子的同时使用口红!");
}
}
}
}
// 化妆不会发生死锁情况
private void makeup(String name,int choice) throws InterruptedException {
if (choice == 0) {
synchronized (lipStick) {// 锁定口红
System.out.println(name + ">>>>使用口红中");
Thread.sleep(1000);
}
synchronized (mirror) {// 口红用完并且释放,再使用镜子
System.out.println(name + ">>>>使用口红结束,开始使用镜子!");
}
} else {
synchronized (mirror) {// 先锁定镜子
System.out.println(name + ">>>>使用镜子中");
}
synchronized (lipStick) {// 镜子用完并且释放,再使用口红
System.out.println(name + ">>>>使用镜子结束,开始使用口红!");
}
}
}
}
形成死锁的执行结果:
小白>>>>使用镜子中
小黑>>>>使用口红中
正常结束,不会形成死锁的执行结果:
小黑>>>>使用口红中
小白>>>>使用镜子中
小黑>>>>使用口红结束,开始使用镜子!
小白>>>>使用镜子结束,开始使用口红!
(2)死锁避免的方法
- 产生死锁的四个必要条件:
- 互斥条件:一个资源每次只能被一个进程使用。
- 请求与保持条件:一个进程因请求资源而阻塞时,对已经获得的资源保持不放。
- 不剥夺条件:进程已获得的资源,在未使用完之前,不能被强行剥夺。
- 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。
上面列出了死锁的四个必要条件,我们只要想办法破其中的任意一个或多个条件就可以避免死锁发生 |
---|
(3)Lock锁
- 从 JDK 5.0开始,Java提供了更强大的线程同步机制–通过显示定义同步锁来实现同步。
同步锁使用Lock对象来充当
。 java.util.concurrent.locks.Lock接口
是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问,每次只能有一个线程对Lock对象加锁,线程开始访问共享资源之前应先获得Lock对象。ReentrantLock(可重入锁)类
实现了Lock接口
,它拥有与synchronized
相同的并发性和内存语义,在实现线程安全的控制中,比较常用的是ReentrantLock(可重入锁)类
,可以显示加锁、释放锁。
代码实现
ReentrantLock(可重入锁)类
// 测试ReentrantLock(可重入锁)类
public class TestLock {
public static void main(String[] args) {
MyLock lock = new MyLock();
new Thread(lock).start();
new Thread(lock).start();
new Thread(lock).start();
}
}
class MyLock implements Runnable {
int ticketNums = 10;
// 定义ReentrantLock(可重入锁)
ReentrantLock reentrantLock = new ReentrantLock();
@Override
public void run() {
while (true) {
// 显示的加锁与释放锁[释放锁是在try...finally{}中释放锁]
reentrantLock.lock();// 加锁
try {
if (ticketNums > 0) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(ticketNums--);
} else {
break;
}
} finally {
// 解锁
reentrantLock.unlock();
}
}
}
}
实现模板:
class A{
// 定义ReentrantLock(可重入锁)
ReentrantLock reentrantLock = new ReentrantLock();
public void M() {
while (true) {
// 显示的加锁与释放锁[释放锁是在try...finally{}中释放锁]
reentrantLock.lock();// 加锁
try {
// 保证线程安全的代码
} finally {
// 解锁
// 如果同步代码有异常,需要将unlock()写入finally语句块
reentrantLock.unlock();
}
}
}
}
synchronized
与Lock
的对比
Lock
是显示锁(手动开启和关闭锁,别忘记关闭锁),synchronized
是隐式锁,出了作用域自动释放;Lock
只用代码块锁,synchronized`有代码块锁和方法锁;- 使用
Lock锁
,JVM 将花费较少的时间来调度线程,性能更好。并且具有更好的扩展性(提供更多的子类); - 优先使用顺序:
-Lock锁
> 同步代码块 (已经进入了方法体,分配了相应的资源)> 同步方法(在方法体之外)