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、利用锁保证一块代码的原子性
这个例子在之前的《关于锁》的笔记中的详细举例，此处就不再列举。
关于锁 我对于锁的初次接触和简单理解
