Java学习笔记 - 第025天

思维导图

Java专题(当天的，后续下篇补充

Java专题.jpg

每日要点

线程相关

线程暂停(进入对象等待池)
parcels.wait();
wait()操作会释放对象的锁
在等待池中的线程需要其他线程将其唤醒

唤醒所有在等待池中等待parcels对象的线程
线程从等待池进入等锁池(等锁池中的线程要抢占到对象锁以后才能进入就绪态)
parcels.notifyAll();

设置优先级改变的是线程获得CPU调度的几率
但是在抢占对象锁的时候优先级高的线程并没有优势
wang.setPriority(Thread.MAX_PRIORITY);

例子1.快递员送货

// 快递员
class DeliveryMan {
    private String name;                // 名字
    private ParcelCenter parcelCenter;  // 包裹中心
    
    public DeliveryMan(String name, ParcelCenter parcelCenter) {
        this.name = name;
        this.parcelCenter = parcelCenter;
    }
    
    // 送快递
    public void send() {
        List parcels = parcelCenter.getParcels();
        synchronized (parcels) {
            // 如果包裹中心没有需要送出的包裹就等待(线程暂停)
            if (parcels.isEmpty()) {
                try {
                    parcels.wait(); // 线程暂停(进入对象等待池)
                    // wait()操作会释放对象的锁
                    // 在等待池中的线程需要其他线程将其唤醒
                }
                catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // 随机取走若干个包裹并送出
            int number = (int) (Math.random() * parcels.size());
            for (int i = 0; i < number; i++) {
                String parcel = parcels.remove(0);
                System.out.println(name + "正在送" + parcel);
            }
        }
    }
}

// 包裹中心
class ParcelCenter {
    private long id = 1;                                // 包裹单号
    private List parcels = new ArrayList<>();   // 装所有包裹的容器
    
    public List getParcels() {
        return parcels;
    }
    
    // 生成需要送出的包裹
    public void generateParcels() {
        String[] names = {"鲜花", "牛奶", "外卖", "信件"};
        // 随机生成1-5件包裹
        int number = (int) (Math.random() * 5 + 1);
        synchronized (parcels) {
            for (int i = 0; i < number; i++) {
                parcels.add("单号[" + id + "]: " 
                        + names[(int) (Math.random() * names.length)]);
                id += 1;
            }
            // 唤醒所有在等待池中等待parcels对象的线程
            // 线程从等待池进入等锁池(等锁池中的线程要抢占到对象锁以后才能进入就绪态)
            parcels.notifyAll();    // 通知快递员已经有包裹可以送出了
        }
    }
}


class Test02 {

    public static void main(String[] args) {
        ParcelCenter center = new ParcelCenter();
        DeliveryMan man1 = new DeliveryMan("王大锤", center);
        DeliveryMan man2 = new DeliveryMan("李莫愁", center);
        // 包裹中心每隔3秒钟产生若干需要送出的包裹
        new Thread(() -> {
            while (true) {
                try {
                    Thread.sleep(3000);
                }
                catch (InterruptedException e) {
                }
                center.generateParcels();
            }
        }).start();
        // 快递员持续送出包裹
        Thread wang = new Thread(() -> {
            while (true) {
                man1.send();
            }
        });
        // 设置优先级改变的是线程获得CPU调度的几率
        // 但是在抢占对象锁的时候优先级高的线程并没有优势
        wang.setPriority(Thread.MAX_PRIORITY);
        wang.start();
        new Thread(() -> {
            while (true) {
                man2.send();
            }
        }).start();
    }
}

深度克隆和浅克隆

例子:

package com.jack;

import java.io.Serializable;

@SuppressWarnings("serial")
class Car implements Serializable{
    private String brand;
    private int  maxSpeed;
    
    public Car(String brand, int maxSpeed) {
        this.brand = brand;
        this.maxSpeed = maxSpeed;
    }
    
    public void setBrand(String brand) {
        this.brand = brand;
    }
    
    public void setMaxSpeed(int maxSpeed) {
        this.maxSpeed = maxSpeed;
    }
    
    @Override
    public String toString() {
        return "Car=[" + brand + ", " + maxSpeed + "]";
    }
}

@SuppressWarnings("serial")
class Student implements /*Cloneable 浅克隆 */  Serializable{
    private String name;
    private int age;
    private Car car;
    
    public Student(String name, int age, Car car) {
        this.name = name;
        this.age = age;
        this.car = car;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public void setAge(int age) {
        this.age = age;
    }
    
    public Car getCar() {
        return car;
    }
    
/*  @Override
    public Object clone() {
        Student temp = null;
        try {
            temp = (Student) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return temp;        
    }*/
    
    @Override
    public String toString() {
        return name + ", " + age + ", " + car.toString();
    }
}


class Test01 {
    
    public static void main(String[] args) {
        Car car = new Car("QQ", 120);
        Student s1 = new Student("王大锤", 18, car);
//      Student s2 = (Student) s1.clone();
        // 深度克隆
        Student s2 = MyUtil.deepClone(s1);
        s2.setName("小白");
        s2.getCar().setBrand("Benz");
        s2.getCar().setMaxSpeed(240);
        System.out.println(s1);
    }
}

运行时异常和非受检异常

Exception

• RuntimeException - 运行时异常(非受检异常)
• ArithmeticException
• NegativeArraySizeException
• IndexOutOfBoundsException
• IllegalMonitorStateException
• NullPointerException
• ClassCastException
• 其他 - 受检异常 - 编译器强制要求处理
• IOException
  • FileNotFoundException
• ClassNotFoundException
• InterruptedException
• CloneNotSupportedException
• SQLException
  例子:

        // System.out.println(3 / 0);
        // int[] a = new int[-3];
        // a[100] = 1000;
        // String str = null;
        // str.toLowerCase();

例子

1.面试题:做一个在内存拷贝的深度克隆方法

public class MyUtil {

    @SuppressWarnings("unchecked")
    public static  T deepClone(T object) {
        T temp = null;
        try {
            // 将对象序列化到内存流中
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(baos);
            oos.writeObject(object);
            // 从内存流中反序列化对象
            byte[] buf = baos.toByteArray();
            ByteArrayInputStream bais = new ByteArrayInputStream(buf);
            ObjectInputStream ois = new ObjectInputStream(bais);
            temp = (T) ois.readObject();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return temp;
    }
}