哈希值-单例模式-线程安全

1、哈希值

hashCode是通过一定规则将引用变为一个int类型的数值，JDK内部写好了这种规则，但我们可以通过重写改变这种规则，而hashCode一般和equals方法同时被重写。为了方便说明 创建一个Animal类

public class Animal {
    private String name;
    private int age;

    public Animal() {
    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

现在我们在测试类中写下如下语句：

public class AniTest {
    public static void main(String[] args) {
        Animal an1 = new Animal("狗", 10);
        Animal an2 = new Animal("猫", 8);
        boolean flag = an1.equals(an2);
        System.out.println(flag);
        System.out.println(an1.hashCode());
        System.out.println(an2.hashCode());
    }
}

显然在没有改写equals和hashCode的情况下，先后输出false和两个不一样的哈希值（暂时不讨论碰撞）。如果此处只改写equals方法：

    @Override
    public boolean equals(Object obj) {
        boolean flag = false;
        Animal an2 = (Animal) obj;
        if (this.name.equals(an2.name)) {//只要姓名相同就视为同一个对象
            flag = true;
        }
        return flag;
    }

public class AniTest {
    public static void main(String[] args) {
        Animal an1 = new Animal("狗", 10);
        Animal an2 = new Animal("猫", 8);
        Animal an3 = new Animal("猫", 7);
        boolean flag = an1.equals(an2);
        System.out.println(flag);
        System.out.println(an2.equals(an3));
        System.out.println(an1.hashCode());
        System.out.println(an2.hashCode());
        System.out.println(an3.hashCode());
    }
}

显然an2.equals(an3)是一个true值，但是二者的哈希值仍不相同，这样会做会使得利用hash的集合类，在使用该类对象做存储的时候，会有意想不到的意外：

    Animal an1 = new Animal("狗", 10);
    Animal an2 = new Animal("猫", 8);
    Animal an3 = new Animal("猫", 7);
    Map<Animal,Integer> map = new HashMap<>();
    map.put(an2, 1);
    map.put(an3, 2);
    System.out.println(map.get(new Animal("猫", 8)));
    System.out.println(map.get(new Animal("猫", 7)));

理论上应该输出1和2，但是最终输出了两个空值，这是因为没有改写hashCode，所以两个实例具有不同的散列码，违反了hashCode的约定，因此，Put方法把对象an2(3)放在一个散列桶里，而get方法去另一个散列桶里查找他的对象。这时就只能找到null。其实即使不重写equals这里也会输出null，不过改写了equals之后，这两个对象在逻辑上应该是等同的，所以应该查找到相应的值。如果我们改写一下hashCode方法（改写方法来自《Effective Java》）

    @Override
    public int hashCode() {
        int result = 17;
        result = 37 * result + this.age;
        return result;
    }

这样再运行测试程序，就能顺利等得到1和2这两个值 了。

2、单例模式

单例模式就是保证类的外部只能同存在一个实例。想要做到这一点，首先就要私有化构造方法，这样就无法通过new产生新的对象。以下用Phone类举例：

public class Phone {
    private Phone() {
    }//私有化构造方法，禁止外部直接访问
}

如果仅仅这样，那么就根本无法产生对象，以下有两种模式来实现单例：

1、饿汉单例

public class Phone {
    private Phone() {
    }
    private static Phone phone=new Phone();//私有化一个静态本类对象，因为在本类内部，所以可以使用构造方法，而且因为是静态的，所以会只会加载一次。
    public static Phone getInstance(){//通过一个静态public方法返回这个对象
        return phone;
    }
}

通过getInstance实例化对象

public class Ph_Test {
    public static void main(String[] args) {
        Phone myPhone1 = Phone.getInstance();
        Phone myPhone2 = Phone.getInstance();
        System.out.println(myPhone1);
        System.out.println(myPhone2);
    }
}

执行程序后，两个Phone的地址相同，即二者指向同一个对象，

饿汉模式还有一种实现方式：

public class Phone {
    private Phone() {
    }

    private static class InstanceKeeper {//利用静态内部类实例化一个静态本类对象，同理是静态的，所以也都只会加载一次
        private static Phone phone = new Phone();
    }

    public static Phone getInstance() {
        return InstanceKeeper.phone;//通过上面的静态内部类获得本类对象
    }
}

2、懒汉单例

public class Phone {
    private Phone() {
    }

    private static Phone phone;//先声明一个私有静态本类对象，但是不实例化

    public static Phone getInstance() {
        if (phone == null) {//如果这个对象为空，那就实例化 这样也可以确保只有一个实例
            phone = new Phone();
        }
        return phone;
    }
}

同理使用饿汉中的验证可以得到两个相同地址的对象。

3、两种单例的缺点

1、懒汉单例

懒汉单例在多线程中可能出现多个不同实例，例如：

public class Ph_Test {
    public static void main(String[] args) {
        Thread t0 = new Thread(() -> {//线程t0利用懒汉实例化
            Phone myPhone1 = Phone.getInstance();
            System.out.println(myPhone1);
        });

        Thread t1 = new Thread(() -> {//线程t1利用懒汉实例化
            Phone myPhone2 = Phone.getInstance();
            System.out.println(myPhone2);
        });
        t0.start();
        t1.start();
    }
}

执行程序后有可能得到不用结果，因为在懒汉中有一个判定对象不为null，如果一个线程将已经实例化的地址返回，另一个线程进来后也判断为null，所以也会实例化一个对象，这就出现了多个不同地址的对象。面对这种问题，最简单的方法是在判断条件里上锁：

public static Phone getInstance() {
    synchronized (Phone.class) {
        if (phone == null) {
            phone = new Phone();
        }
    }
    return phone;
}

这样，多线程就可以同步，确保同时只存在一个不为空的对象实例。不过上锁本身需要消耗资源，如果对每个线程都上锁，那么会大大增加开销，如果在上锁之前先进行一次模糊的判断，那样可以减少很多次上锁的过程：

private volatile static Phone phone;//volatile可以使phone能够在线程运行过程中，值发生变化后能及时返回主内存，被其他线程读取到

    public static Phone getInstance() {//双重检验
        if (phone == null) {//如果phone不为null直接返回phone，不用加锁
            synchronized (Phone.class) {
                if (phone == null) {
                    phone = new Phone();
                }
            }
        }
        return phone;
    }

因为之前实验证明，多个线程异步时即使phone为null，也不能保证phone没有被（或正在被）实例化，但是如果不为null，那肯定被实例化了，加上外层判断能过滤掉绝大部分已经实例化的线程，剩下少部分再通过锁来保证实例的单一性。

2、饿汉单例

饿汉单例是线程安全的，不需要加锁，因为静态内容只会加载一次，也正因为只加载一次，那么如果在外部获得单例之后将单例变为null之后，该类的对象就只能为null。

3、线程安全

说到线程安全就不得不提与之相关的三大特性：原子性、可见性和一致性。

1、原子性

所谓原子，在以前被认为是最小的粒子，不可再分割。这里用原子来命名这种性质也有这个含义：当一个操作不能够被中断，这个操作的结果要么是全部成功，要么是全部失败。

int a=0;//1
int b=a;//2
a++;//3
a+=2;//4

上面四个操作中，只有1是原子性的。在2中，先从a中读取数值，然后赋值给b，是两步操作。而3和4本质上是一样的，从a中获取数值，运算数值，将运算结果赋值给a，是三步操作。在java内存中有8种操作被认为是原子性的，一般基本数据类型的访问和读写都可以算原子性，只有64位数据类型可以分为2次32位操作（最新的JDK中其实也可以实现原子性）。

2、可见性

在了解可见性之前，要事先了解一些Java的内存模型。在Java中分为主内存和工作内存，所有数据都存储在主内存中，而每个线程也有自己的工作内存。当工作内存需要数据时，会从主内存获得一份数据的副本，然后再工作区内进行处理，之后会将处理好的数据副本更新到主内存中：


多线程内存模型

从这个模型可以看出，如果有的线程正在在执行过程中，还没有返回数据到主内存中时，另一个线程已经从主内存在读取完（过时）数据了，这就是不可见。而在java中，可见性就是指一旦任意工作内存修改了数据，能够马上被其它所有线程知晓这个修改。

3、有序性

下面请看：

int a = 10;//1
int b = 5;//2
int c= a + b;//3

正常情况下应该按照123的顺序执行代码，但是在java中为了进行优化可能会对指令按照一定规则进行重排。例如此处就可以按照213的顺序执行，这完全不会影响结果。但是这种重排只在本线程内有效，有人这样总结：在本线程内操作都是有序的，但是观察另一个线程所有操作就是无序的。例如：

public class ForFun {
    private boolean flag = false;
    private int a = 2;

    public void change() {
        a = 3;//1
        flag = true;//2
    }

    public void res() {
        if (flag) {
            System.out.println(Thread.currentThread().getName() + ":" + a * a);
        }
    }
}

有线程1调用change方法，线程2调用res方法。对于线程1，它对在change经过重排，按2->1的顺序运行。在运行完2之后，flag为true，此时线程2正好运行判断语句，最后输出的结果是4，而不是9。

4、volatile关键字

之前在单例模式中，除了利用锁保证原子性外，还使用了一个关键字volatile。它用来修饰变量，有两个作用：1、保证该变量的可见性。2、禁止发生重排，即保证了有序性。。但是volatile并不能完全保证原子性，事实上如果一个被volatile修饰的变量进行了多步操作，那么就无法保证原子性：

public class Test {
    public volatile int inc = 0;

    public void increase() {
        inc++;
    }
}

public class ForFunTest {
    public static void main(String[] args) {
        final Test test = new Test();
        for (int i = 0; i < 10; i++) {
            Thread tt = new Thread(() -> {
                for (int j = 0; j < 1000; j++)
                    test.increase();
            });
            tt.start();
        }
        while (Thread.activeCount() > 1) {  //保证前面的线程都执行完
            Thread.yield();
            System.out.println(test.inc);
        }
    }
}

输出的结果并不想象中的10000，一般都是小这个数。这是因为volatile关键字只能够及时更新数据的变化，如果一个线程A获得inc数据10还没开始自加，因为数据没有变化，显然volatile并不会起作用。此时线程B也开始获得inc数据，这是只能获取10，而当A加完后将数据更新到主内存后，B也随后加完更新至主内存中，此时主内存中inc被同样的数据11刷新了两次，B线程的这次操作其实是无效（或者说有效但没有意义）的，这就导致的最后的结果小于10000.事实上甚至会低于6500。

5、如何保证线程安全

1、避免多线程，尽量将操作放在单线程中。

2、线程封闭

1、栈封闭：将变量定义在方法中

对于方法而言，内部的变量会随着方法的产生而产生的，也会随着方法的结束而被回收。所以多线程在执行同样的方法时，其实是在各自的方法中修改变量，并不会影响到其他线程。

2、ThreadLocale封闭

对于必须使用全局变量的数据，使用ThreadLocale，这样也能保证对于变量操作的原子性。

public class ForFun {
    private boolean flag = false;
    private ThreadLocal<Integer> a = new ThreadLocal<>();

    public void change() {
        a.set(2);
        flag = true;
        try {
            Thread.sleep(1000);//休眠1秒 其它线程能够进来
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        a.set(3);
    }

    public void res() {
        if (flag) {
            System.out.println(Thread.currentThread().getName() + ":" + a.get());
        }
    }
}

public class ForFunTest {
    public static void main(String[] args) {
        ForFun ff = new ForFun();
        Thread t0 = new Thread(() -> {
            ff.change();
            ff.res();
        });

        Thread t1 = new Thread(() -> {
            ff.change();
            ff.res();
        });

        t0.start();
        t1.start();
    }
}

无论运行多少次，结果显然都是3。

3、利用锁保证一块代码的原子性

这个例子在之前的《关于锁》的笔记中的详细举例，此处就不再列举。
关于锁 我对于锁的初次接触和简单理解

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 219,701评论 6赞 508
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 93,649评论 3赞 396
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 166,037评论 0赞 356
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 58,994评论 1赞 295
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 68,018评论 6赞 395
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 51,796评论 1赞 308
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 40,481评论 3赞 420
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 39,370评论 0赞 276
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 45,868评论 1赞 319
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 38,014评论 3赞 338
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 40,153评论 1赞 352
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 35,832评论 5赞 346
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 41,494评论 3赞 331
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 32,039评论 0赞 22
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 33,156评论 1赞 272
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 48,437评论 3赞 373
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 45,131评论 2赞 356