【Java】—— 多线程：线程安全的懒汉式_ 死锁_ ReentrantLock的使用

于 2024-09-25 17:42:46 发布
阅读量664 收藏 14
点赞数 11
分类专栏： JAVA 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_63106307/article/details/142528921
版权

·

目录

6.1 单例设计模式的线程安全问题

6.1.1 饿汉式没有线程安全问题

6.1.2 懒汉式线程安全问题

6.2 死锁

6.3 JDK5.0新特性：Lock(锁)

6.1 单例设计模式的线程安全问题

6.1.1 饿汉式没有线程安全问题

饿汉式：在类初始化时就直接创建单例对象，而类初始化过程是没有线程安全问题的

public class HungrySingle {
    private static HungrySingle INSTANCE = new HungrySingle(); //对象是否声明为final 都可以
    
    private HungrySingle(){}
    
    public static HungrySingle getInstance(){
        return INSTANCE;
    }
}

测试类：

public class HungrySingleTest {

    static HungrySingle hs1 = null;
    static HungrySingle hs2 = null;

    //演示存在的线程安全问题
    public static void main(String[] args) {

        Thread t1 = new Thread() {
            @Override
            public void run() {
                hs1 = HungrySingle.getInstance();
            }
        };

        Thread t2 = new Thread() {
            @Override
            public void run() {
                hs2 = HungrySingle.getInstance();
            }
        };

        t1.start();
        t2.start();

        try {
            t1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        try {
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(hs1);
        System.out.println(hs2);
        System.out.println(hs1 == hs2);//true
    }

}
6.1.2 懒汉式线程安全问题

懒汉式：延迟创建对象，第一次调用getInstance方法再创建对象

形式一：

public class LazyOne {
    private static LazyOne instance;

    private LazyOne(){}

    //方式1：
    public static synchronized LazyOne getInstance1(){
        if(instance == null){
            instance = new LazyOne();
        }
        return instance;
    }
    //方式2：
    public static LazyOne getInstance2(){
        synchronized(LazyOne.class) {
            if (instance == null) {
                instance = new LazyOne();
            }
            return instance;
        }
    }
    //方式3：
    public static LazyOne getInstance3(){
        if(instance == null){
            synchronized (LazyOne.class) {
                try {
                    Thread.sleep(10);//加这个代码，暴露问题
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if(instance == null){
                    instance = new LazyOne();
                }
            }
        }

        return instance;
    }
    /*
    注意：上述方式3中，有指令重排问题
    mem = allocate(); 为单例对象分配内存空间
    instance = mem;   instance引用现在非空，但还未初始化
    ctorSingleton(instance); 为单例对象通过instance调用构造器
    从JDK2开始，分配空间、初始化、调用构造器会在线程的工作存储区一次性完成，然后复制到主存储区。但是需要   
    volatile关键字，避免指令重排。
    */
    
}

形式二：使用内部类

public class LazySingle {
    private LazySingle(){}
    
    public static LazySingle getInstance(){
        return Inner.INSTANCE;
    }
    
    private static class Inner{
        static final LazySingle INSTANCE = new LazySingle();
    }
    
}

内部类只有在外部类被调用才加载，产生INSTANCE实例；又不用加锁。

此模式具有之前两个模式的优点，同时屏蔽了它们的缺点，是最好的单例模式。

此时的内部类，使用enum进行定义，也是可以的。

测试类：

import org.junit.Test;

public class TestLazy {
    @Test
    public void test01(){
        LazyOne s1 = LazyOne.getInstance();
        LazyOne s2 = LazyOne.getInstance();

        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s1 == s2);
    }

    //把s1和s2声明在外面，是想要在线程的匿名内部类中为s1和s2赋值
    LazyOne s1;
    LazyOne s2;
    @Test
    public void test02(){
        Thread t1 = new Thread(){
            public void run(){
                s1 = LazyOne.getInstance();
            }
        };
        Thread t2 = new Thread(){
            public void run(){
                s2 = LazyOne.getInstance();
            }
        };

        t1.start();
        t2.start();

        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s1 == s2);
    }


    LazySingle obj1;
    LazySingle obj2;
    @Test
    public void test03(){
        Thread t1 = new Thread(){
            public void run(){
                obj1 = LazySingle.getInstance();
            }
        };
        Thread t2 = new Thread(){
            public void run(){
                obj2 = LazySingle.getInstance();
            }
        };

        t1.start();
        t2.start();

        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(obj1);
        System.out.println(obj2);
        System.out.println(obj1 == obj2);
    }
}

6.2 死锁

不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁。

【小故事】

面试官：你能解释清楚什么是死锁，我就录取你！

面试者：你录取我，我就告诉你什么是死锁！

….

恭喜你，面试通过了

一旦出现死锁，整个程序既不会发生异常，也不会给出任何提示，只是所有线程处于阻塞状态，无法继续。

举例1：

public class DeadLockTest {
	public static void main(String[] args) {

		StringBuilder s1 = new StringBuilder();
		StringBuilder s2 = new StringBuilder();

		new Thread() {
			public void run() {
				synchronized (s1) {
					s1.append("a");
					s2.append("1");
					
					try {
						Thread.sleep(10);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}

					synchronized (s2) {
						s1.append("b");
						s2.append("2");

						System.out.println(s1);
						System.out.println(s2);

					}
				}
			}
		}.start();

		new Thread() {
			public void run() {
				synchronized (s2) {
					s1.append("c");
					s2.append("3");

					try {
						Thread.sleep(10);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					
					synchronized (s1) {
						s1.append("d");
						s2.append("4");

						System.out.println(s1);
						System.out.println(s2);

					}

				}
			}
		}.start();

	}
}

举例2：

public class TestDeadLock {
	public static void main(String[] args) {
		Object g = new Object();
		Object m = new Object();
		Owner s = new Owner(g,m);
		Customer c = new Customer(g,m);
		new Thread(s).start();
		new Thread(c).start();
	}
}
class Owner implements Runnable{
	private Object goods;
	private Object money;

	public Owner(Object goods, Object money) {
		super();
		this.goods = goods;
		this.money = money;
	}

	@Override
	public void run() {
		synchronized (goods) {
			System.out.println("先给钱");
			synchronized (money) {
				System.out.println("发货");
			}
		}
	}
}
class Customer implements Runnable{
	private Object goods;
	private Object money;

	public Customer(Object goods, Object money) {
		super();
		this.goods = goods;
		this.money = money;
	}

	@Override
	public void run() {
		synchronized (money) {
			System.out.println("先发货");
			synchronized (goods) {
				System.out.println("再给钱");
			}
		}
	}
}

诱发死锁的原因：

  • 互斥条件

  • 占用且等待

  • 不可抢夺（或不可抢占）

  • 循环等待

以上4个条件，同时出现就会触发死锁。

解决死锁：

死锁一旦出现，基本很难人为干预，只能尽量规避。可以考虑打破上面的诱发条件。

针对条件1：互斥条件基本上无法被破坏。因为线程需要通过互斥解决安全问题。

针对条件2：可以考虑一次性申请所有所需的资源，这样就不存在等待的问题。

针对条件3：占用部分资源的线程在进一步申请其他资源时，如果申请不到，就主动释放掉已经占用的资源。

针对条件4：可以将资源改为线性顺序。申请资源时，先申请序号较小的，这样避免循环等待问题。

6.3 JDK5.0新特性：Lock(锁)

  • JDK5.0的新增功能，保证线程的安全。与采用synchronized相比，Lock可提供多种锁方案，更灵活、更强大。Lock通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。

  • java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。

  • 在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。

    • ReentrantLock类实现了 Lock 接口，它拥有与 synchronized 相同的并发性和内存语义，但是添加了类似锁投票、定时锁等候和可中断锁等候的一些特性。此外，它还提供了在激烈争用情况下更佳的性能。

  • Lock锁也称同步锁，加锁与释放锁方法，如下：

    • public void lock() :加同步锁。

    • public void unlock() :释放同步锁。

  • 代码结构

注意：如果同步代码有异常，要将unlock()写入finally语句块。

举例：

import java.util.concurrent.locks.ReentrantLock;

class Window implements Runnable{
	int ticket = 100;
    //1. 创建Lock的实例，必须确保多个线程共享同一个Lock实例
	private final ReentrantLock lock = new ReentrantLock();
	public void run(){
		
		while(true){
			try{
                //2. 调动lock()，实现需共享的代码的锁定
				lock.lock();
				if(ticket > 0){
					try {
						Thread.sleep(10);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(ticket--);
				}else{
					break;
				}
			}finally{
                //3. 调用unlock()，释放共享代码的锁定
				lock.unlock();
			}
		}
	}
}

public class ThreadLock {
	public static void main(String[] args) {
		Window t = new Window();
		Thread t1 = new Thread(t);
		Thread t2 = new Thread(t);
		
		t1.start();
		t2.start();
	}
}

synchronized与Lock的对比

  1. Lock是显式锁（手动开启和关闭锁，别忘记关闭锁），synchronized是隐式锁，出了作用域、遇到异常等自动解锁

  2. Lock只有代码块锁，synchronized有代码块锁和方法锁

  3. 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类），更体现面向对象。

  4. （了解）Lock锁可以对读不加锁，对写加锁，synchronized不可以

  5. （了解）Lock锁可以有多种获取锁的方式，可以从sleep的线程中抢到锁，synchronized不可以

说明：开发建议中处理线程安全问题优先使用顺序为：

• Lock ----> 同步代码块 ----> 同步方法

星星法术嗲人
关注
专栏目录
多线程-线程安全的懒汉式_死锁-ReentrantLock的使用
qq_45761228的博客
06-07 893
线程安全的懒汉式_死锁-ReentrantLock的基本使用
Java——多线程高并发系列之Lock、ReentrantLock
★★光亭★★
06-09 7327
Java——多线程高并发系列之Lock、ReentrantLock
ReentrantLock替换synchronized解决多线程并发死锁，Java
Zhang Phil
11-01 478
Java并发多线程环境中，造成死锁的最简单的场景是：多线程中的一个线程T_A持有锁L1并且申请试图获得锁L2，而多线程中另外一个线程T_B持有锁L2并且试图申请获得锁L1。线程的锁申请操作是阻塞的，于是造成线程T_A和线程T_B无法正确获得想要的锁，两个线程被阻塞进入死锁状态。Java线程同步锁ReentrantLock和Condition中断等待程序前提条件满足_zhangphil的博客-CSDN博客。
java多线程：ReentrantLock的使用，实现共享变量线程安全
ko8be24的博客
11-29 861
1.ReentrantLock的介绍 ReentrantLock是独占锁且是可重入的 ReentrantLock可以实现公平锁 ReentrantLock可中断响应 ReentrantLock可获取锁时限时等待 2.使用ReentrantLock的lock方法获取锁，unlock方法释放锁，模拟多线程实例如下： public class LockDemo { pr...
Java多线程——死锁
u010759175的专栏
12-28 1136
话不多说先来个例子说明 灰姑娘和白雪公主化妆，但是同时拿着对方的资源不释放，形成了僵持的局面 //死锁：多个线程互相抱着对方需要的资源，形成僵持 public class DeadLock { public static void main(String[] args) { MakeUp m1 = new MakeUp(0,"灰姑娘"); MakeUp m2 = new MakeUp(1,"白雪公主"); m1.start(); m2.start(); } } //口红 class
【JAVA面试题】探索多线程同步：ReentrantLock与synchronized的对比解析
热门推荐
Venus's Blog
04-22 3万+
是 Java 中用于实现锁的一个类，它提供了与关键字类似的功能，但更加灵活和强大。与相比，提供了更多的操作和控制选项。是 Java 中用于实现线程同步的关键字，可以用来确保多个线程不会同时访问共享资源，从而避免数据竞争和不确定的结果。在多线程编程中，选择合适的线程同步机制对于程序的性能和正确性至关重要。和都是有效的线程同步机制，每种机制都有其优势和适用场景。在实际开发中，我们应该根据具体的需求和场景来选择合适的机制，并且在编写多线程代码时，始终注意避免死锁和性能瓶颈等问题，以确保程序的正确性和高效性。
Java多线程（六） 解决多线程安全——ReentrantLock及源码解析
lizefeng1998的博客
09-24 479
Java多线程（五） 解决多线程安全——ReentrantLock及源码解析 Java多线程（五） 解决多线程安全——ReentrantLock及源码解析ReentrantLock的使用ReentrantLock与synchronized区别ReentrantLock的特性ReentrantLock 源码解析ReentrantReadWriteLock锁 在之前的文章《Java多线程（三） 多线程不安全的典型例子》中我写到了在多线程环境中经常会碰到多线程非安全的情况，并且举出了三种典型例子，之后我在上一篇
Java基础——多线程详解！！！！
qq_52519008的博客
10-04 4843
就是进程中的一个独立控制单元，线程在控制着进程的执行。一个进程中至少有一个进程。多线程是多任务的一种特别的形式，但多线程使用了更小的资源开销。多线程能满足程序员编写高效率的程序来达到充分利用 CPU 的目的。注意：很多多线程是模拟出来的，真正的多线程是指有多个CPU，即多核，如服务器。如果是模拟出来的多线程，即在一个CPU的情况下，在同一个时间点，CPU只执行一个代码，因为切换得很快，所以就有同时执行的错觉。程序、进程和线程的大家可以通过百度搜索得知，在这里我就不多阐述。
Java多线程6：ReentrantLock同步锁
何哥的博客
09-07 1489
前言：Java除了使用关键字synchronized外，还可以使用ReentrantLock实现独占锁的功能。而且ReentrantLock相比synchronized而言功能更加丰富，使用起来更为灵活，也更适合复杂的并发场景。这篇文章主要是从使用的角度来分析一下ReentrantLock。 一、Lock接口简介 1.1、Lock接口概述 在JUC包下面有一个java.util.concurrent.locks包，这个包提供了一系列基础的锁工具，对传统的synchronizd、wait和notif
java多线程抢占资源_java 多线程争抢资源死锁
weixin_29027305的博客
02-13 910
多线程争抢资源死锁的原理就是，A线程正在持有锁1却想获取锁2，B线程正在持有锁2却要获取锁1代码如下：public class Main {static ReentrantLock lock1 = new ReentrantLock();static ReentrantLock lock2 = new ReentrantLock();static class Test1 implements Ru...
Java多线程结构_Java多线程结构_
09-30
Java多线程结构是Java编程中的重要组成部分，它允许程序同时执行多个任务，提升系统效率。在Java中，实现多线程主要有两种方式：继承Thread类和实现Runnable接口。 1. 继承Thread类： 当自定义类继承Thread类时，...
JAVA-JavaThreadProgramming-Sams.zip_JAVA 设计_java 多线程_java 线程_多线程
09-14
Java提供了多种同步机制来解决多线程环境下的数据安全问题，如synchronized关键字、 volatile变量、Lock接口（如ReentrantLock）以及Semaphore信号量等。synchronized提供了内置锁，可以保证同一时刻只有一个线程...
java多线程设计模式_java_设计模式_多线程_多线程课题_
09-29
Java多线程设计模式是Java开发中的核心概念，它涉及到如何高效、安全地在多个执行线程之间共享资源和协调任务。设计模式是解决特定问题的成熟方案，它们是编程经验的结晶，可以帮助开发者在面临多线程挑战时快速找到...
Java多线程 ReentrantLock互斥锁详解
08-25
Java多线程ReentrantLock互斥锁详解 ReentrantLock是Java多线程编程中的一种锁机制，它可以实现线程之间的同步访问资源。ReentrantLock的主要特点是可以重入，即一个线程可以多次获得锁，而不需要释放锁。这种机制...
Java多线程-避免同步机制带来的死锁问题及用Lock锁解决线程安全问题
02-02
### Java多线程-避免同步机制带来的死锁问题及用Lock锁解决线程安全问题 #### 死锁 ##### 1. 说明 在多线程编程中，死锁是一种常见的问题，指的是两个或多个线程在执行过程中，因为竞争资源而造成的一种相互等待...
工厂模式的介绍及实现
最新发布
户伟伟的博客
09-25 94
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
Java Stream流编程入门
2301_77207909的博客
09-21 554
Java StreamAPI的使用与常用方法
智能BI平台项目
2302_79400545的博客
09-22 221
BI商业智能：数据可视化、报表可视化系统。
Android系统：系统架构
liufeismart2024的博客
09-23 451
Android的系统结构的设计混合了分层设计和分块设计。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值