【java基础】17.锁

最新推荐文章于 2024-01-15 14:04:31 发布

米殇粟

最新推荐文章于 2024-01-15 14:04:31 发布

阅读量117

点赞数

分类专栏： # java基础J2SE 文章标签： java基础锁

本文链接：https://blog.csdn.net/jianmingxie/article/details/78727753

版权

java基础J2SE 专栏收录该内容

24 篇文章 0 订阅

订阅专栏

线程间的通信：

wait与notify方法都是定义在Object类中，而且是final的，因此会被所有的Java类所继承并且无法重写。这两个方法要求在调用时线程应该已经获得了对象的锁，因此对这两个方法的调用需要放在synchronized方法或块当中。当线程执行了wait方法时，它会释放掉对象的锁。

wait();notify();notifyAll();

都使用在同步中，因为要对持有监视器(锁)的线程操作，所以要使用在同步中，因为只有同步才具有锁的概念。

为什么这些操作线程的方法定义在了Object类中呢？

因为这些方法在操作中同步线程时，都必须要标识他们所操作线程具有的锁，只有同一个锁上的被等待线程，可以被同一个锁上的notify唤醒，不可以对不同锁中的线程进行唤醒。即 等待和唤醒必须是同一个锁，而锁可以是任意对象，所以可被任意对象调用的方法定义在了Object类中。

此方法只应由作为此对象监视器的所有者的线程来调用。通过以下三种方法之一，线程可以成为此对象监视器的所有者：

通过执行此对象的同步 (Sychronized) 实例方法。

通过执行在此对象上进行同步的 synchronized 语句的正文。

对于 Class 类型的对象，可以通过执行该类的同步静态方法。

一次只能有一个线程拥有对象的监视器。

另一个会导致线程暂停的方法就是Thread类的sleep方法，它会导致线程睡眠指定的毫秒数，但线程在睡眠的过程中是不会释放掉对象的锁的。

JDK1.5中提供了多线程的解决方案

将同步Synchronized替换成lock实现。

将Object中的wait、notify、notifyAll替换成了Condition对象。

生产者消费者问题

哲学家就餐

对象的深拷贝与浅拷贝

–浅复制（浅克隆）：被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。

–深复制（深克隆）：被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深复制把要复制的对象所引用的对象都复制了一遍。

•Java的clone()方法【定义在Object类中】

–clone方法将对象复制了一份并返回给调用者。一般而言，clone（）方法满足：

–①对任何的对象x，都有x.clone() !=x

•克隆对象与原对象不是同一个对象

–②对任何的对象x，都有x.clone().getClass()= =x.getClass()

•克隆对象与原对象的类型一样

–③如果对象x的equals()方法定义恰当，那么x.clone().equals(x)应该成立。

•Java中对象的克隆步骤

–①为了获取对象的一份拷贝，我们可以利用Object类的clone()方法。

–②在派生类中覆盖基类的clone()方法，并声明为 public【Object类中的clone()方法为protected的】。

–③在派生类的clone()方法中，调用super.clone()。

–④在派生类中实现Cloneable接口。

•说明：

–①为什么我们在派生类中覆盖Object的clone()方法时，一定要调用super.clone()呢？

•在运行时刻，Object中的clone()识别出你要复制的是哪一个对象，然后为此对象分配空间，并进行对象的复制，将原始对象的内容一一复制到新对象的存储空间中。

–② 继承自java.lang.Object类的clone()方法是浅复制

eg：浅复制

public class CloneTest1{
    public static void main(String[] args) throws Throwable{
        Student student = new Student();
        student.setAge(20);
        student.setName("zhangsan");
        Student student2 = (Student)student.clone();
        System.out.println(student2.getAge());
        System.out.println(student2.getName());
        System.out.println("----------------------");
        student2.setName("lisi");
        System.out.println(student.getName());
        System.out.println(student2.getName());
    }
} 
class Student implements Cloneable{
    private int age;
    private String name;
    public int getAge(){
        return age;
    }
    public void setAge(int age){
        this.age = age;
    }
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name = name;
    }
    @Override
    public Object clone() throws CloneNotSupportedException{
        Object object = super.clone();
        return object;
    }

深复制

public class CloneTest2{
    public static void main(String[] args) throws Exception{
        Teacher teacher = new Teacher();
        teacher.setAge(40);
        teacher.setName("Teacher zhang");
        Student2 s1 = new Student2();
 
        s1.setAge(20);
        s1.setName("zhangsan");
        s1.setTeacher(teacher);
        Student2 s2 = (Student2)s1.clone();
 
        System.out.println(s2.getName());
        System.out.println(s2.getAge());
        teacher.setName("Teacher Li");
        System.out.println(s2.getTeacher().getName());
        System.out.println(s2.getTeacher().getAge());
    }
}
class Teacher implements Cloneable{
    private int age;
    private String name;
    public int getAge(){
        return age;
    }
    public void setAge(int age){
        this.age = age;
    }
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name = name;
    }
    @Override
    public Object clone() throws CloneNotSupportedException{
        return super.clone();
    }
}
class Student2 implements Cloneable{
    private int age;
    private String name;
    private Teacher teacher;
    public int getAge(){
        return age;
    }
    public void setAge(int age){
        this.age = age;
    }
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name = name;
    }
    public Teacher getTeacher(){
        return teacher;
    }
    public void setTeacher(Teacher teacher){
        this.teacher = teacher;
    }
    @Override
    public Object clone() throws CloneNotSupportedException{
        Student2 student2 = (Student2)super.clone();
        student2.setTeacher((Teacher)student2.getTeacher().clone());
        return student2;
    }
}

利用序列化实现深复制

•在Java语言里深复制一个对象，常常可以先使对象实现Serializable接口，然后把对象（实际上只是对象的一个拷贝）写到一个流里，再从流里读出来，便可以重建对象。

•这样做的前提是对象以及对象内部所有引用到的对象都是可串行化的，否则，就需要仔细考察那些不可串行化的对象可否设成transient，从而将之排除在复制过程之外

public class CloneTest3{
    public static void main(String[] args) throws Exception{
        Teacher3 t = new Teacher3();
        t.setAge(40);
        t.setName("Teacher Zhang");
        Student3 s1 = new Student3();
 
        s1.setAge(20);
        s1.setName("zhangsan");
        s1.setTeacher(t);
        Student3 s2 = (Student3)s1.deepCopy();
 
        System.out.println(s2.getAge());
        System.out.println(s2.getName());
        System.out.println("-----------------------");
        System.out.println(s2.getTeacher().getAge());
        System.out.println(s2.getTeacher().getName());
 
        s2.getTeacher().setAge(50);
        s2.getTeacher().setName("Teacher Li");
        System.out.println(s1.getTeacher().getAge());
        System.out.println(s1.getTeacher().getName());
    }   
}
class Teacher3 implements Serializable{
    private int age;
    private String name;
    public int getAge(){
        return age;
    }
    public void setAge(int age){
        this.age = age;
    }
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name = name;
    }
}
class Student3 implements Serializable{
    private int age;
    private String name;
    private Teacher3 teacher;
    public int getAge(){
        return age;
    }
    public void setAge(int age){
        this.age = age;
    }
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name = name;
    }
    public Teacher3 getTeacher() {
        return teacher;
    }
    public void setTeacher(Teacher3 teacher){
        this.teacher = teacher;
    }
    public Object deepCopy() throws Exception{
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(this);
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        return ois.readObject();
    }
}

注：此文档为学习圣思园风中叶教程结合自身学习所记录。

米殇粟

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【java基础】17.锁

线程间的通信：wait与notify方法都是定义在Object类中，而且是final的，因此会被所有的Java类所继承并且无法重写。这两个方法要求在调用时线程应该已经获得了对象的锁，因此对这两个方法的调用需要放在synchronized方法或块当中。当线程执行了wait方法时，它会释放掉对象的锁。 wait();notify();notifyAll();都使用在同步中，因为
复制链接

扫一扫