笔试学习记录(网易2)

水深无声 2021-09-24 03:26 350阅读 0赞

# 单例模式-双重校验锁 #

package single;
    
    /** * Dcl懒汉式 双重校验 */
    
    public class Single3 { 
        private Single3() { 
        }
    
        private static volatile Single3 Instance = null;
    
        public static Single3 getInstance() { 
            //第一次校验
            if (Instance == null) { 
                synchronized (Single3.class) { 
                    //第二次校验
                    if (Instance == null) { 
                        Instance = new Single3();  //这里不是一个原子性操作
                        /** * jvm指令重排优化 导致的现象 * * 1、分配内存空间 * 2、执行构造方法、初始化对象 * 3、把这个对象指向这个空间 * * 我们期望的执行顺序是123 * 但是真实可能执行132，比如第一个线程t1进来的时候，执行132顺序，这是没有问题的。但是突然来了一条线程t2。 * 但是由于他已经指向了这个空间了，也就是他会认为这Instance！=null(第一次校验)，这是他就会直接 return * Instance;此时这个Instance还没有完成构造，空间是一片虚无的。 所以我们要保证Instance避免发生指令重排， * 也就是要加上关键字 volatile 。 */
                    }
                }
            }
            return Instance;
        }
    
    }

**为什么需要两次判断if(singleTon==null)?**

答：  
第一次校验：由于单例模式只需要创建一次实例，如果后面再次调用getInstance方法时，则直接返回之前创建的实例，因此大部分时间不需要执行同步方法里面的代码，大大提高了性能。如果不加第一次校验的话，那跟上面的懒汉模式没什么区别，每次都要去竞争锁。

第二次校验：如果没有第二次校验，假设线程t1执行了第一次校验后，判断为null，这时t2也获取了CPU执行权，也执行了第一次校验，判断也为null。接下来t2获得锁，创建实例。这时t1又获得CPU执行权，由于之前已经进行了第一次校验，结果为null（不会再次判断），获得锁后，直接创建实例。结果就会导致创建多个实例。所以需要在同步代码里面进行第二次校验，如果实例为空，则进行创建。

**注意：**  
　　需要注意的是，private static volatile SingleTon3 singleTon=null;需要加volatile关键字，否则会出现错误。问题的原因在于JVM指令重排优化的存在。在某个线程创建单例对象时，在构造方法被调用之前，就为该对象分配了内存空间并将对象的字段设置为默认值。此时就可以将分配的内存地址赋值给instance字段了，然而该对象可能还没有初始化。若紧接着另外一个线程来调用getInstance，取到的就是状态不正确的对象，程序就会出错。  
　　  
　　静态内部类：同样也是利用了类的加载机制，它与饿汉模式不同的是，它是在内部类里面去创建对象实例。这样的话，只要应用中不使用内部类，JVM就不会去加载这个单例类，也就不会创建单例对象，从而实现懒汉式的延迟加载。也就是说这种方式可以同时保证延迟加载和线程安全。

# Java为什么会引入Lambda表达式？ #

在Java8出现之前，如果你想传递一段代码到另一个方法里是很不方便的。你几乎不可能将代码块到处传递，因为Java是一个面向对象的语言，因此你要构建一个属于某个类的对象，由它的某个方法来放置你想传递的代码块。下面看两个非常典型的例子，构造线程与比较器。

## 不使用Lambda表达式。 ##

构造线程：

我们要想在另一个线程中执行一些代码逻辑时，通常会将代码放在一个实现Runnable接口的run方法当中，如下图：

public static void main(String[] args) { 
        myThread t = new myThread();
    
    }
    
    class myThread implements Runnable { 
        @Override
        public void run() { 
            System.out.println("放入你想执行的代码");
        }
    }

你写这段代码的目的就是想开启新的线程来执行你定制的代码，为此你创建了myThread。

接着我们看下构造比较器：

public static void main(String[] args) { 
        List<Integer> list = new ArrayList<>();
        list.add(2);
        list.add(5);
        list.add(1);
        list.add(4);
        list.add(3);
    
        Comparator<Integer> comparator = new Comparator<Integer>() { 
            @Override
            public int compare(Integer o1, Integer o2) { 
                return o2 - o1;
            }
        };
        Collections.sort(list, comparator);
    }

sort 方法会不断调用compare 方法，对顺序不对的元素进行重新排序，直到有序为止。你写比较器的目的就是给Collections的sort方法传递一段比较逻辑的代码片段，这段代码会被整合到排序排序逻辑中，为此你写了一个类和一个方法。

上述两个例子你会看到它们的相似点，将一段代码传递给其他调用者（一个线程池或者一个排序方法），这段代码会在新的方法中被调用。

但是，在Java8出现之前，如果你想传递一段代码到另一个方法里是很不方便的，因为Java是一个面向对象的语言，因此你要构建一个属于某个类的对象，由它的某个方法来放置你想传递的代码块。而在一些其他语言中可以直接传递代码块，比如JS。为此，Java决定加入了lambda表达式的语法糖。

## 使用Lambda表达式。 ##

对于传入比较器代码块，我们的目的是想传入一段比较逻辑，利用lambda表达式可以：

lambda表达式的语法格式是：参数->一个表达式，如果想传入的代码无法用一个表达式表示，则可以用 参数->\{多个表达式\}。如果没有参数需要传递，则可以用()->表达式的形式。

public static void main(String[] args) { 
    
            List<Integer> list = new ArrayList<>();
            list.add(2);
            list.add(5);
            list.add(1);
            list.add(4);
            list.add(3);
    
            Collections.sort(list, (one,two)->{ 
                System.out.println("one="+one);
                System.out.println("two="+two);
                return two - one;
            });
        }

编译器会解析出来 one 与 two 是原先接口compare方法的入参，并自动赋予Integer类型。

对于构造线程，我们的目的就是想传入一段线程执行的代码，利用lambda表达式可以这样做：

public static void main(String[] args) { 
    
        new Thread(() -> { 
            for (int i = 0; i < 100; i++) { 
    
                System.out.println("这是一个线程" + i);
            }
        }).start();
    
        for (int i = 100; i < 200; i++) { 
            System.out.println("这是主线程" + i);
        }
    }

从上述的例子可以看出，有了lambda表达式，传递代码块变得更为简单，对于一些特定的使用场景，例如Steam API，lambda会大大提高你的代码效率，并且比传统的方式要更为易读（当然，前提是你知道lambda表达式的语法）。

总的来说，所有的lambda表达式都是延迟执行的，如果你希望立即执行一段代码，那就没必要使用lambda表达式了，延迟执行代码的原因有很多种：

在另一个线程中运行代码  
多次运行代码  
在某个算法的正确时间点上运行代码（如排序中的比较逻辑）  
某些条件触发时运行代码（数据到达，接口回调等）  
在实际工作中还是比较推荐大家使用的，有人可能会拿性能说事，但你想一想lambda表达的性能损耗可比查询一次MySQL代价小的太多了。