一、单例模式中的线程问题
1.1什么是单例模式
单例模式属于创建类型的一种常用的软件设计模式。通过单例模式的方法创建的类在当前进程中只有一个实例。要实现这一点，可以从客户端对其进行实例化，因此需要用一种只允许生成对象类的唯一实例的机制，“阻止”所有想要生成对象的访问。
java中单例模式的定义“一个类有且仅有一个实例，并且自行实例化向整个系统提供。”
java单例模式代码（懒汉模式——线程不安全）
//单例模式示例代码： public class Singleton{ private Singleton(){ } private static volatile Singleton instance = null; public static Singleton getInstamce(){ if (instance == null){ synchronized(Singleton.class){ if(instance == null){ instance = new Singleton(); } } } return instance; } }
1.2单例模式构建方式
懒汉式——线程不安全：最基础的实现方式，线程上下文单例，不需要共享给所有线程，也不要加synchronize锁，以提高性能。
懒汉式——线程安全：加上synchronize之类保证线程安全的基础上的懒汉模式，相对性能低。
饿汉式：指全局的单例实例在类装载时构建。
双检索式：在懒汉式基础上利用synchronize关键字和volatile关键字确保第一次创建没有线程相争，仅第一次创建时同步，性能相对较高。
登记式：作为创建类的全局属性存在，创建类被装载时创建。
枚举：其本身也是一种单例模式
1.3两种方式的代码实例
懒汉式——线程安全
饿汉式代码示例
通过对比发现，饿汉式代码更加简洁，且没有线程安全问题，懒汉式更加节约内存（调用返回实例方式时才创建对象）
二、死锁问题
线程安全问题常常是程序员最关注的问题，为了保证线程安全问题，如上就会添加一些锁机制，可是在不当的位置添加就会产生死锁问题。
2.1死锁的定义：
死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者彼此通信而造成的一种阻塞的现象。简单来说一种无限的相互等待的状态，两个或两个以上的线程或者进程构成一个互相等待的环状。
//线程的死锁案例 public class DeadLockDemo { //创建两个锁对象 private static Object LockA = new Object(); private static Object LockB = new Object(); public static void main(String[] args) { Thread thread1 = new Thread(()-> { synchronized (LockA) { System.out.println("线程1拥有锁A，需要锁B"); try { Thread.sleep(10); } catch (InterruptedException e) { throw new RuntimeException(e); } synchronized (LockB) { System.out.println("线程1拥有锁A、锁B"); } } }); Thread thread2 = new Thread(()-> { synchronized (LockB) { System.out.println("线程2拥有锁B，需要锁A"); try { Thread.sleep(10); } catch (InterruptedException e) { throw new RuntimeException(e); } synchronized (LockA) { System.out.println("线程2拥有锁A、锁B"); } } }); //启动线程1、2 thread1.start(); thread2.start(); } }
死锁示例代码运行结果
在以上示例中，我们创建了两个线程1,2，并且每个线程都需要两把锁才能继续执行。当线程1拥有A需要B时，线程2拥有B需要A，这就导致了死锁现象。
2.2产生死锁的原因及条件
产生死锁的原因有很多，通常包括：竞争资源引起进程死锁，可剥夺资源和不可剥夺资源，竞争不可剥夺资源，竞争临时资源。虽然进程在运行过程中，可能发生死锁，但死锁的发生也必须具备一定的条件，死锁发生必须具备一下四个条件:
1）互斥条件：指进程对所分配到的资源进行排它性使用，即在一段时间内某资源只由一个进程占用。如果此时还有其它进程请求资源，则请求者只能等待，直至占有资源的进程用毕释放。
2）请求和保持条件：指进程已经保持至少一个资源，但又提出了新的资源请求，而该资源已被其它进程占有，此时请求进程阻塞，但又对自己已获得的其它资源保持不放。
3）不剥夺条件：指进程已获得的资源，在未使用完之前，不能被剥夺，只能在使用完时由自己释放。
4）循环等待条件：指在发生死锁时，必然存在一个进程——资源的环形链，即进程集合{P0，P1，P2，···，Pn}中的P0正在等待一个P1占用的资源；P1正在等待P2占用的资源，……，Pn正在等待已被P0占用的资源。
2.3解决死锁问题
死锁一旦出现，很难认为干预，只能尽量规避，通常解决办法有三种：死锁预防、死锁避免、死锁检测和解除。一般可以考虑打破上面的四个诱发条件。
--->互斥条件基本上无法被破坏，因此线程需要通过互斥解决安全问题
--->可以考虑一次性申请所有所需的资源，消除资源等待问题
--->占用部分资源的进程在进一步申请其他资源时，若申请不到，就主动释放已经占有的资源
--->对资源进行排序，申请资源，按序分配，避免循环等待
为了避免死锁，我们需要遵循一些规则（此处借鉴与此原文链接：https://blog.csdn.net/hj1993/article/details/131713286）
只在必要时使用多个锁。如果只需要一个锁，就不要使用两个锁。
尽量避免在持有锁的情况下调用其他对象的方法。如果必须这样做，请确保该方法不会尝试获取当前锁所持有的任何其他锁。
避免循环依赖。如果线程A需要在持有锁1的情况下获取锁2，并且线程B需要在持有锁2的情况下获取锁1，则存在循环依赖问题。
使用tryLock()而不是synchronized代码块来获取锁。tryLock()方法可以尝试获取锁，如果获取失败则立即返回。这可以避免死锁。
修改后的死锁代码示例：
//线程的死锁避免案例 public class AvoidDeadLockDemo { //创建两个锁对象 private static Object LockA = new Object(); private static Object LockB = new Object(); public static void main(String[] args) { Thread thread1 = new Thread(()-> { synchronized (LockA) { System.out.println("线程1拥有锁A，需要锁B"); try { Thread.sleep(10); } catch (InterruptedException e) { throw new RuntimeException(e); } synchronized (LockB) { System.out.println("线程1拥有锁A、锁B"); } } }); Thread thread2 = new Thread(()-> { boolean locked = false; while(!locked) { locked = LockB.tryLock(); if (locked) { System.out.println("线程2拥有锁B，需要锁A"); try { Thread.sleep(10); } catch (InterruptedException e) { throw new RuntimeException(e); } synchronized (LockA) { System.out.println("线程2拥有锁A、锁B"); } } else { System.out.println("线程2失去锁B"); } } }); //启动线程1、2 thread1.start(); thread2.start(); } }
