jdk源码之Object

最新推荐文章于 2022-07-17 17:29:10 发布

微卡Chou

最新推荐文章于 2022-07-17 17:29:10 发布

阅读量120

点赞数

分类专栏： jdk源码解析文章标签： java

本BLOG上原创文章未经本人许可，不得用于商业用途。转载请注明出处，否则保留追究法律责任的权利。

本文链接：https://blog.csdn.net/xuanxxxxxx/article/details/116139916

版权

jdk源码解析专栏收录该内容

12 篇文章 0 订阅

订阅专栏

jdk源码之Object

一、类图

在这里插入图片描述
Object类是所有类的父类。
Object一部分方法是native方法，问题来了，那么何为native方法？

native关键字标识的java方法为本地方法，底层是有c/c++编写的程序编译后dll文件，java加载dll文件后，通过本地方法调用dll中函数。

二、构造方法

Object有默认的无参构造，没有显示的提供出来。

三、registerNatives 方法

	private static native void registerNatives();
    static {
        registerNatives();
	}

作用是将C/C++中的函数映射到Java中的native方法。

四、getClass 方法

	public final native Class<?> getClass();

final代表不能被重写。返回类运行时的类型。

五、hashCode 方法

	public native int hashCode();

返回对象的hash值。
遵循三个规则：

在一个Java应用程序的执行过程中，无论何时对同一个对象调用多次，{@code hashCode}方法都必须始终如一地返回相同的整数，前提是没有任何信息被修改。这个整数不需要从一个应用程序的执行到另一个相同的应用程序的执行保持一致。
如果根据{@code equals(Object)}方法，两个对象是相等的，那么在两个对象上分别调用{@code hashCode}方法必须产生相同的整数结果。
如果根据{@link java.lang.Object#equals(java.lang.Object)}方法，两个对象是不相等的，那么在这两个对象上调用{@code hashCode}方法产生的整数值也不是一定非要不同。然而，程序员应该知道，为不相等的对象产生不同的整数结果可能会提高哈希表的性能。

六、equals 方法

	public boolean equals(Object obj) {
        return (this == obj);
    }

equals方法主要是比较两个对象是否相同，Object中的equals方法比较的是对象的地址是否相同。

七、clone 方法

	protected native Object clone() throws CloneNotSupportedException;

clone方法是创建并且返回一个对象的复制之后的结果。

这个方法的要保证下面的三个表达式成立：

   x.clone() != x
   x.clone().getClass() == x.getClass();
   x.clone().equals(x);

返回的对象应该通过调用super.clone()来取得。如果需要复制的类的成员变量是由基本类型或者由指向不可变对象的引用(列如String)组成，那么我们不需要任何修改，直接对对象调用clone方法即可。
被克隆的类需要实现Cloneable接口，否则在复制对象时会报异常。

浅拷贝例子

class House {
    private String addr;
    public House(String addr) {
        this.setAddr(addr);
    }
    public String getAddr() {
        return addr;
    }
    public void setAddr(String addr) {
        this.addr = addr;
    }

}
class Person implements Cloneable {
    private String name;
    private House house;
    public Person(String name, House house) {
        this.setName(name);
        this.setHouse(house);
    }
    @Override
    public Object clone() {
        //浅拷贝
        try {
            return super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
            return null;
        }   
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public House getHouse() {
        return house;
    }
    public void setHouse(House house) {
        this.house = house;
    }

}
public class ShallowClone {
    public static void main(String[] args) {
        House house = new House("地址");
        Person person = new Person("名字", house);
        Person personClone = (Person) person.clone();
        //这里我改变person对象中的house，可以看到personClone中的house也进行了变化
        person.getHouse().setAddr("新地址");
        System.out.println(personClone.getHouse().getAddr()); 
    }

}

深拷贝例子

class House implements Cloneable {
    private String addr;
    public House(String addr) {
        this.setAddr(addr);
    }
    public String getAddr() {
        return addr;
    }
    public void setAddr(String addr) {
        this.addr = addr;
    }
    @Override
    public Object clone() {
        try {
            return super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
            return null;
        }
    }

}
class Person implements Cloneable {
    private String name;
    private House house;
    public Person(String name, House house) {
        this.setName(name);
        this.setHouse(house);
    }
    @Override
    public Object clone() {
        Person p = null;
        try {
            p = (Person) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        p.house = (House) p.house.clone();
        return p;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public House getHouse() {
        return house;
    }
    public void setHouse(House house) {
        this.house = house;
    }

}
public class DeepClone {

    public static void main(String[] args) throws CloneNotSupportedException {
        House house = new House("地址");
        Person person = new Person("名字", house);
        Person personClone = (Person) person.clone();
        person.getHouse().setAddr("新地址");
        System.out.println(personClone.getHouse().getAddr()); 
    }
}

实现深拷贝还有一种方式是进行对象的序列化。

浅拷贝：浅拷贝是按位拷贝对象，它会创建一个新对象，这个对象有着原始对象属性值的一份精确拷贝。如果属性是基本类型，拷贝的就是基本类型的值；如果属性是内存地址（引用类型），拷贝的就是内存地址，因此如果其中一个对象改变了这个地址，就会影响到另一个对象。
深拷贝：深拷贝会拷贝所有的属性,并拷贝属性指向的动态分配的内存。当对象和它所引用的对象一起拷贝时即发生深拷贝。深拷贝相比于浅拷贝速度较慢并且花销较大。

八、toString 方法

	public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

返回类名 + @ + 哈希值的16进制。

九、notify 方法

	public final native void notify();

通知可能等待该对象的对象锁的其他线程。由JVM(与优先级无关)随机挑选一个处于wait状态的线程。

在调用notify()之前，线程必须获得该对象的对象级别锁
执行完notify()方法后，不会马上释放锁，要直到退出synchronized代码块，当前线程才会释放锁
notify()一次只随机通知一个线程进行唤醒

十、notifyAll方法

    public final native void notifyAll();

和notify()差不多，只不过是使所有正在等待池中等待同一共享资源的全部线程从等待状态退出，进入可运行状态。
让它们竞争对象的锁，只有获得锁的线程才能进入就绪状态。
每个锁对象有两个队列：就绪队列和阻塞队列

就绪队列：存储将要获得锁的线程
阻塞队列：存储被阻塞的线程

十一、wait方法

有三种重载方法

    public final native void wait(long timeout) throws InterruptedException;
	public final void wait(long timeout, int nanos) throws InterruptedException {
        if (timeout < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (nanos < 0 || nanos > 999999) {
            throw new IllegalArgumentException(
                                "nanosecond timeout value out of range");
        }

        if (nanos > 0) {
            timeout++;
        }

        wait(timeout);
    }
    public final void wait() throws InterruptedException {
        wait(0);
    }

可见wait()和wait(long timeout, int nanos)都在在内部调用了wait(long timeout)方法。
下面主要是说说wait(long timeout)方法
wait方法会引起当前线程阻塞，直到另外一个线程在对应的对象上调用notify或者notifyAll()方法，或者达到了方法参数中指定的时间。
调用wait方法的当前线程一定要拥有对象的监视器锁。
wait方法会把当前线程T放置在对应的object上的等到队列中，在这个对象上的所有同步请求都不会得到响应。线程调度将不会调用线程T，在以下四件事发生之前，线程T一直处于休眠状态（线程T是在其代码中调用wait方法的那个线程）

当其他的线程在对应的对象上调用notify方法，而在此对象的对应的等待队列中将会任意选择一个线程进行唤醒。
其他的线程在此对象上调用了notifyAll方法
其他的线程调用了interrupt方法来中断线程T
等待的时间已经超过了wait中指定的时间。如果参数timeout的值为0，不是指真实的等待时间是0，而是线程等待直到被另外一个线程唤醒。
被唤醒的线程T会被从对象的等待队列中移除并且重新能够被线程调度器调度。之后，线程T会像平常一样跟其他的线程竞争获取对象上的锁；一旦线程T获得了此对象上的锁，那么在此对象上的所有同步请求都会恢复到之前的状态，也就是恢复到wait被调用的情况下。然后线程T从wait方法的调用中返回。因此，当从wait方法返回时，对象的状态以及线程T的状态跟wait方法被调用的时候一样。
线程在没有被唤醒，中断或者时间耗尽的情况下仍然能够被唤醒，这叫做伪唤醒。虽然在实际中，这种情况很少发生，但是程序一定要测试这个能够唤醒线程的条件，并且在条件不满足时，线程继续等待。换言之，wait操作总是出现在循环中，就像下面这样：

synchronized(对象){
    while(条件不满足){
     对象.wait();
  	}
  对应的逻辑处理
}

如果当前的线程被其他的线程在当前线程等待之前或者正在等待时调用了interrupt()中断了，那么会抛出InterruptedExcaption异常。直到这个对象上面的锁状态恢复到上面描述的状态以前，这个异常是不会抛出的。
要注意的是，wait方法把当前线程放置到这个对象的等待队列中，解锁也仅仅是在这个对象上；当前线程在其他对象上面上的锁在当前线程等待的过程中仍然持有其他对象的锁。
这个方法应该仅仅被持有对象监视器的线程调用。
wait(long timeout, int nanos)方法的实现中只要nanos大于0，那么timeout时间就加上一毫秒，主要是更精确的控制时间，其他的跟wait(long timeout)一样。

为什么wait方法一般要写在while循环里
一般在我们编程的时候wait方法都是写在while循环中，while循环中是测试条件，主要有以下几个原因：