线程安全 单例模式

单例模式的实现方式

单例模式属于创建型模式,提供了一种创建对象的最佳方式.

特点:

• 一个单例类只能有一个实例
• 单例类必须自己创建自己的唯一实例
• 在提供这个唯一实例的时候必须保证唯一性

使用场景:

1. 创建某些对象要消耗的资源太多,重复创建效率非常低,比如,I/O和数据库连接池,线程池等
2. 要求生产唯一序列号
3. WEB中的计数器,可以先使用单例存储

设计要求:

• 一个私有的构造函数 确保只能由单例类自己创建实例
• 一个公有的静态方法 用于提供给使用者内部实例的方法
• 一个私有静态变量 保证实例的唯一性

实现方式:

懒汉式(线程不安全):

class Singleton_hunger{private static Singleton_hunger instance;private Singleton_hunger(){}public static Singleton_hunger getInstance() {if(instance==null){instance = new Singleton_hunger();}return instance;}
}

说明:因为只有在第一次调用getInsrance方法的时候才会创建实例,所以被叫做懒汉式

**优点:**在不使用这个类的时候,这个资源不会被实例化,节省了资源,

**缺点:**线程不安全,当有多个线程同时调用getInstance()方法,进入if(insrance==null)语句,那么在此时instance确实没有被创建.那么会有多个线程对这个资源进行实例化,造成了资源的浪费

懒汉式(线程安全):

public class Singleton {private static Singleton uniqueInstance;private static singleton() {}
//加了synchronized同步锁private static synchronized Singleton getUinqueInstance() {if (uniqueInstance == null) {uniqueInstance = new Singleton();}return uniqueInstance;}}

**说明:**加入了synchronized同步锁关键字,锁大小为getUinqueInstance()方法,保证同时只有一个线程能进入,从而解决了多个线程同时实例化的问题

但是在后续使用中,因为资源并不会发生改变.不存在线程安全问题.此时这个同步锁会成为性能的桎梏.

**优点:**延迟实例化，节约了资源，并且是线程安全的。

**缺点:**性能的降低

饿汉式(线程安全)

public class Singleton {private static Singleton uniqueInstance = new Singleton();private Singleton() {}public static Singleton getUniqueInstance() {return uniqueInstance;}}

**说明:**顾名思义,他比较饥渴,哈哈哈.在创建这个类的时候就将这个资源实例化好

**优点:**线程安全

**缺点:**如果不使用这个资源的话,会造成资源的浪费

静态内部类实现（线程安全)

public class Singleton {private Singleton() {}private static class SingletonHolder {private static final Singleton INSTANCE = new Singleton();}public static Singleton getUniqueInstance() {return SingletonHolder.INSTANCE;}}

**说明:**在外部类Singleton加载的时候,内部SingletonHolder类不会被加载进内存,

当调用getUniqueInstance()方法的时候,此时会运行 return SingletonHolder.INSTANCE;语句,此时静态内部类才会被加载进内存,并且初始化这个实例的时候,JVM机制因为会保证类只被加载一次,所以这个资源也只会被实例化一次.

优点: 延迟实例化，节约了资源；且线程安全；性能也提高了。

缺点:无?

双重校验锁DCL(线程安全，效率高)

class Singleton_double {//一个私有静态变量private static volatile Singleton_double instance;//一个私有构造方法private Singleton_double (){}//一个提供给外接的共有方法获取实例public static Singleton_double getInstance(){if(instance == null){synchronized(Subgleton_double.class){if(instance == null){instance = new Singleton_double();}}}return instance;}}

volatile关键字添加的原因

在 instance = new Singleton_double();执行过程中可能会分为三步

1. 先为instance实例分配内存空间
2. 对instance进行初始化
3. 返回instance对象

但是JVM是具有指令重排序的优化的,此时在多线程的情况下,可能导致未进行初始化的时候,就将instance对象返回.导致程序出错.

volatile关键字会使得JVM进行指令重排序

**缺点:**volatile对性能有一定影响

枚举类线程安全

public enum Singleton {INSTANCE;//添加自己需要的操作public void doSomeThing() {}}

枚举类默认就是线程安全的

构造方法

初始化Employee类的时候,Person作为父类要先进行初始化,但是因为有 有参构造没有无参构造(没有构造方法会默认有一个)

所以在子类初始化的时候,如果没有使用super.构造方法 来进行父类构造方法的指定,那么就会调用父类无参构造,当父类没有无参构造方法,需要子类显式调用父类的构造函数.

可以使用super.(nm);加在低8行

剑指 Offer 25. 合并两个排序的链表 - 力扣（LeetCode） (leetcode-cn.com)

/*** Definition for singly-linked list.* public class ListNode {*     int val;*     ListNode next;*     ListNode(int x) { val = x; }* }*/
class Solution {public ListNode mergeTwoLists(ListNode l1, ListNode l2) {ListNode head = new ListNode(0);
ListNode tail = head;while(l1!=null && l2!=null){if(l1.val<l2.val){tail.next = l1;l1 = l1.next;}else{tail.next = l2;l2 = l2.next;} tail = tail.next;}tail.next = l1==null?l2:l1;return head.next;}
}

剑指 Offer 27. 二叉树的镜像 - 力扣（LeetCode） (leetcode-cn.com)

/*** Definition for a binary tree node.* public class TreeNode {*     int val;*     TreeNode left;*     TreeNode right;*     TreeNode(int x) { val = x; }* }*/
class Solution {public TreeNode mirrorTree(TreeNode root) {if(root == null){return null;}mirrorTree(root.left);mirrorTree(root.right);exchange(root);return root;}public static void exchange(TreeNode root){TreeNode temp = root.left;root.left = root.right;root.right = temp;}
}

剑指 Offer 28. 对称的二叉树 - 力扣（LeetCode） (leetcode-cn.com)

/*** Definition for a binary tree node.* public class TreeNode {*     int val;*     TreeNode left;*     TreeNode right;*     TreeNode(int x) { val = x; }* }*/
import java.util.*;
class Solution {public boolean isSymmetric(TreeNode root) {//递归搜索//当两个子节点都为null,到了叶子结点//当一个子节点为空返回false不对称if(root==null){return true;}return check(root.left,root.right);}public boolean check(TreeNode left,TreeNode right){if(left==null && right==null){return true;}if(left==null || right==null || left.val != right.val ){return false;}return check(left.left,right.right)&&check(left.right,right.left);}
}