Java笔记思维导图

1、一句话概括
在java中，线程阻塞状态是线程本身不可计划的，而线程等待状态是线程本身计划之内的。

2、相同点与不同点
相同点：
（1）都会暂停线程的执行。

区别点：
（1）线程进入阻塞状态是被动的, 而线程进入等待状态是主动的。
阻塞状态的被动：线程在同步代码外（就是snychronized或者lock—unlock代码块之外），获取对象锁失败时，线程进入阻塞状态；何时获取对象锁失败不可知，即线程阻塞状态是线程本身不可计划的。
等待状态的主动：线程在同步代码内，等待其他线程操作时，线程接入等待状态；何时等待其他线程操作可知，即线程等待状态是线程本身计划之内的。

Tip：再简单的说就是，同步代码块以外的是阻塞状态，以内的是等待状态！

https://pic4.zhimg.com/80/v2-1319f27379e4745d02b40ea12b9307cb_720w.webp

如何定位死锁，解决问题？

1、使用jps定位进程号，jdk的bin目录下： 有一个jps
命令：jps -l

2、使用jstack 进程进程号 找到死锁信息（jstack是jvm中自带的堆栈跟踪工具）
命令：jstack 进程号

产生死锁的四个必要条件：

1. 互斥条件（Mutual Exclusion）：每个资源最多只能由一个线程持有。
2. 请求与保持条件（Hold and Wait）：线程持有至少一个资源，并且在等待其他线程拥有的资源。
3. 不可抢占条件（No Preemption）：资源只能在持有者释放之后由其他线程获取，不能被强制抢占。
4. 循环等待条件（Circular Wait）：存在一个线程等待列表的循环链，每个线程等待链中的资源被下一个线程持有。

默认非公平锁，可通过构造方法传入true参数，启用公平锁

/**
 * 独占锁（写锁） 一次只能被一个线程占有
 * 共享锁（读锁）  多个线程可以同时占有
 * 
 * ReadWriteLock
 * 读-读  可以共存！
 * 读-写  不可共存！
 * 写-写  不可共存！
 */
public class ReadWriteLockDemo {
    public static void main(String[] args) {
        MyCache myCache = new MyCache();

        for (int i = 1; i <= 5; i++) {
            final int temp = i;
            //写入
            new Thread(() -> {
                myCache.put(temp + "", temp + "");
            }, String.valueOf(i)).start();
        }

        for (int i = 1; i <= 5; i++) {
            final int temp = i;
            //读取
            new Thread(() -> {
                System.out.println("获取" + temp + "缓存数据-> " + myCache.get(temp + ""));
            }, String.valueOf(i)).start();
        }
    }
}

/**
 * 自定义缓存
 */
class MyCache {

    private volatile Map<String, Object> map = new HashMap<>();
    private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    /**
     * 存 写
     */
    public void put(String key, Object value) {
        readWriteLock.writeLock().lock();
        System.out.println(Thread.currentThread().getName() + "写入" + key);
        try {
            TimeUnit.MILLISECONDS.sleep(200);
            map.put(key, value);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            readWriteLock.writeLock().unlock();
        }
        System.out.println(Thread.currentThread().getName() + "写入OK");
    }

    /**
     * 取 读
     */
    public Object get(String key) {
        readWriteLock.readLock().lock();
        Object o = null;
        try {
            System.out.println(Thread.currentThread().getName() + "读取" + key);
            o = map.get(key);
            System.out.println(Thread.currentThread().getName() + "读取OK");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.readLock().unlock();
        }
        return o;
    }
}

1. 对于普通同步方法，锁是当前实例对象。
2. 对于静态同步方法，锁是当前类的Class对象。
3. 对于同步方法块，锁是synchronized括号里配置的对象。

CountDownLatch(减法计数器)

CyclicBarrier(加法计数器)

Semaphore(信号量)

Java无法操作内存，那么就通过这个类去访问底层资源、去操作内存

线程不安全，但效率高，想要线程安全用Vecotr

线程安全，但效率较低

线程不安全，解决方法：
Collections.synchronizedList(new LinkedList<>());

底层亦是HashMap
线程不安全，解决如下：
    //解决方案一：
Set<String> set = Collections.synchronizedSet(new HashSet<>());
    //解决方案二：
Set<String> set = new CopyOnWriteArraySet<>();

JDK1.8 之前：

• 数组+链表

JDK1.8之后：

• 数组+链表+红黑树

    解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为 8）（将链表转换成红黑树前会判断，如果当前数组的长度小于 64，那么会选择先进行数组扩容，而不是转换为红黑树）时，将链表转化为红黑树，以减少搜索时间。

//双重检测锁模式的 懒汉式单例 DCL懒汉式
    public static LazyMan getInstance() {
        if (null == lazyMan) {
            synchronized (LazyMan.class) {
                if (null == lazyMan) {
                    lazyMan = new LazyMan(); // 不是一个原子性操作
                }
            }
        }
        return lazyMan;
    }

单例不安全, 因为反射，可以使用枚举类做单例！

class LazySingleton {
    String name = "单例";
    private static boolean initialized = false;

    private LazySingleton() {
        //防止反射对其单例模式进行破坏
        if (initialized) {
            throw new RuntimeException("不允许创建多个实例！");
        }
        initialized = true;
    }

    static LazySingleton getInstance() {
        return LazyHolder.LAZY_SINGLETON;
    }

    private final static class LazyHolder {
        private static final LazySingleton LAZY_SINGLETON = new LazySingleton();
    }

    /**
     * 防止序列化破坏单例模式
     */
    @Serial
    private Object readResolve() {
        return LazyHolder.LAZY_SINGLETON;
    }
}

/**
 * 枚举单例模式
 */
@Getter
enum EnumSingleton implements Serializable {
    SINGLETON();
    private Integer code;
    private String name;

    public static EnumSingleton getSingletonInstance() {
        return SINGLETON;
    }
}

使用枚举实现的单例模式是最安全的，无法通过反射进行实例化。当我们使用枚举来实现单例时，枚举本身就提供了保证单例唯一性和安全性的机制。

/**
 * 浅拷贝
 * 拷贝（克隆）PrototypePattern对象，引用地址是不同，即是两个不同的实例，但是里面的属性age、name是引用相同的地址，这就是浅拷贝！
 */
@Data
class PrototypePattern implements Cloneable{
    private int age = 20;
    private String name = "浅拷贝";

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    /**
     * 或者下面的浅克隆方法
     */
//    protected PrototypePattern clone() {
//        PrototypePattern prototypePattern = new PrototypePattern();
//        prototypePattern.setAge(this.getAge());
//        prototypePattern.setName(this.getName());
//        return prototypePattern;
//    }
}

/**
 * 深拷贝：意义在于拷贝的对象，里外都是要不一样（即地址要不一样）！
 * 拷贝（克隆）PrototypePattern对象，引用地址是不同，即两个不同的实例。且里面的属性age、name、组合的对象，也都是引用不同的地址，这就是深拷贝！
 */
@Data
class PrototypePattern implements Cloneable, Serializable {
    private int age = 20;
    private String name = "深拷贝";

    /**
     * 类里组合了其他的类，或者数组List，必须要初始化，没有初始化就是null，那么即使是深拷贝，也是指向null的这个引用对象，那么深拷贝也是一样的
     */
    private List<String> list = new ArrayList<>();

    @Override
    protected Object clone() throws CloneNotSupportedException {
        //序列化方式深拷贝一：将序列化的对象数据写入内存中的字节数组中。
        try {
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(baos);
            oos.writeObject(this);

            ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bais);
            return ois.readObject();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        //序列化方式深拷贝二：将序列化的对象数据写入到文件中。这里不再代码赘述
    }
}

静态代理只能通过手动完成代理操作，如果被代理类增加了
新的方法，代理类需要同步增加，违背开闭原则。所有基本是不会去使用静态代理。

JDK动态代理

CGLib动态代理

CGLib和JDK动态代理对比