温习JAVA

1.时间

作业题：

1.子串在字符串中出现的次数

import java.util.Scanner;
 
/**
 * 分别在控制台输⼊字符串和⼦字符
 * 串，并计算字符串中⼦字符串出现的
 * 次数。indexOf(subs,n)
 */
public class H5 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        String str=sc.next();
        String subs=sc.next();
        int i=0;
        int count=0;
        while((i=str.indexOf(subs, i ))!=-1) {
            count++;
            i=i+1;
        }
        System.out.println("子串出现次数"+count);
    }
}

2.Map

3.TreeMap

它的comparator 有意思，相等时会覆盖

4.字节输入流和字节输出流

一个简单的案例：

当读到文件末尾EOF时，返回-1 

先开启的  后关闭

5.序列化和反序列化

6.Arrays.copyOfRange()

包头不包尾

7.共享数据时，自然而然的想起  static

8.多线程

8.1 join()

相当于插队，调用此方法的线程插队当前正在执行的线程。

8.2 详细讲一下中断

简介：中断相关的有三个方法 interrupt() interrupted() isInterrupted()

首先，明确一点，对于执行中的线程，即使使用interrup()t对 其发送中断请求，仅仅是改变该线程的中断状态，设置为true.  而如果你想进行中断，可以配合  isInterruped()来使用

现在来介绍一下 interrupted() ,它跟 isInterrupted()的作用很像，会返回true 或false

,但当它检测中断位改为true时，它不会立即返回true,而是返回false，再把中断位改为true,下一次检测中断位时，再退出。  相当于留了一次循环给线程做剩余的事。

interrupt()

后半句更加精髓，当发出信号，直到线程调用wait(),sleep(),join()才会抛出中断异常。

更确切的说，如果线程被Object.wait, Thread.join和Thread.sleep三种方法之一阻塞，此时调用该线程的interrupt()方法，那么该线程将抛出一个 InterruptedException中断异常（该线程必须事先预备好处理此异常），从而提早地终结被阻塞状态。如果线程没有被阻塞，这时调用 interrupt()将不起作用，直到执行到wait(),sleep(),join()时,才马上会抛出 InterruptedException。

8.2 volatile

8. 3   自旋锁，乐观锁

1.什么是自旋锁

这跟操作系统中判断中断，很像

2.什么是cas算法

3.java相关源码解析

看下阿伟的解析更清晰： 

o是内存中的值，是新值，v是旧值，比较新值和旧值是否相同，如果相同再进行更改，如果不同，继续循环，不断更新旧值，直到新值和旧值相同，结束空转，修改值。

源码如下:

 
//先自增，然后获取自增后的结果
public final int incrementAndGet() {
        //+ 1 自增后的结果
        //this 就表示当前的atomicInteger（值）
        //1    自增一次
        return U.getAndAddInt(this, VALUE, 1) + 1;
}
 
public final int getAndAddInt(Object o, long offset, int delta) {
        //v 旧值
        int v;
        //自旋的过程
        do {
            //不断的获取旧值
            v = getIntVolatile(o, offset);
            //如果这个方法的返回值为false，那么继续自旋
            //如果这个方法的返回值为true，那么自旋结束
            //o 表示的就是内存值
            //v 旧值
            //v + delta 修改后的值
        } while (!weakCompareAndSetInt(o, offset, v, v + delta));
            //作用：比较内存中的值，旧值是否相等，如果相等就把修改后的值写到内存中，返回true。表示修改成功。
            //                                 如果不相等，无法把修改后的值写到内存中，返回false。表示修改失败。
            //如果修改失败，那么继续自旋。
        return v;
}

9.Interface 可以继承接口

10.发现同步代码块的锁挺奇怪的，能用在方法上，锁的对象也是有要求的。唤醒和等待时，通过锁来唤醒和等待。

好文章复制  ：内置锁和可重入锁

在 Java 中，常用的锁有两种：synchronized（内置锁）和 ReentrantLock（可重入锁），二者的功效都是相同得，但又有很多不同点，所以我们今天就来聊聊。

区别1：用法不同

synchronized 可用来修饰普通方法、静态方法和代码块，而 ReentrantLock 只能用在代码块上。

synchronized 基础使用

使用 synchronized 修饰代码块：

public void method() {
    // 加锁代码
    synchronized (this) {
        // ...
    }
}

ReentrantLock 基础使用

ReentrantLock 在使用之前需要先创建 ReentrantLock 对象，然后使用 lock 方法进行加锁，使用完之后再调用 unlock 方法释放锁，具体使用如下：

public class LockExample {
    // 创建锁对象
    private final ReentrantLock lock = new ReentrantLock();
    public void method() {
        // 加锁操作
        lock.lock();
        try {
            // ...
        } finally {
            // 释放锁
            lock.unlock();
        }
    }
}

区别2：获取锁和释放锁方式不同

synchronized 会自动加锁和释放锁，当进入 synchronized 修饰的代码块之后会自动加锁，当离开 synchronized 的代码段之后会自动释放锁，如下图所示：

而 ReentrantLock 需要手动加锁和释放锁，如下图所示：

PS：在使用 ReentrantLock 时要特别小心，unlock 释放锁的操作一定要放在 finally 中，否者有可能会出现锁一直被占用，从而导致其他线程一直阻塞的问题。

区别3：锁类型不同

synchronized 属于非公平锁，而 ReentrantLock 既可以是公平锁也可以是非公平锁。
默认情况下 ReentrantLock 为非公平锁，这点查看源码可知：

使用 new ReentrantLock(true) 可以创建公平锁，查看源码可知：

区别4：响应中断不同

ReentrantLock 可以使用 lockInterruptibly 获取锁并响应中断指令，而 synchronized 不能响应中断，也就是如果发生了死锁，使用 synchronized 会一直等待下去，而使用 ReentrantLock 可以响应中断并释放锁，从而解决死锁的问题，比如以下 ReentrantLock 响应中断的示例：

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
 
public class ReentrantLockInterrupt {
    static Lock lockA = new ReentrantLock();
    static Lock lockB = new ReentrantLock();
    public static void main(String[] args) throws InterruptedException {
        // 线程 1：先获取 lockA 再获取 lockB
        Thread t1 = new Thread(() -> {
            try {
                // 先获取 LockA
                lockA.lockInterruptibly();
                // 休眠 10 毫秒
                TimeUnit.MILLISECONDS.sleep(100);
                // 获取 LockB
                lockB.lockInterruptibly();
            } catch (InterruptedException e) {
                System.out.println("响应中断指令");
            } finally {
                // 释放锁
                lockA.unlock();
                lockB.unlock();
                System.out.println("线程 1 执行完成。");
            }
        });
        // 线程 2：先获取 lockB 再获取 lockA
        Thread t2 = new Thread(() -> {
            try {
                // 先获取 LockB
                lockB.lockInterruptibly();
                // 休眠 10 毫秒
                TimeUnit.MILLISECONDS.sleep(100);
                // 获取 LockA
                lockA.lockInterruptibly();
            } catch (InterruptedException e) {
                System.out.println("响应中断指令");
            } finally {
                // 释放锁
                lockB.unlock();
                lockA.unlock();
                System.out.println("线程 2 执行完成。");
            }
        });
        t1.start();
        t2.start();
        TimeUnit.SECONDS.sleep(1);
        // 线程1：执行中断
        t1.interrupt();
    }
}

以上程序的执行结果如下所示：

区别5：底层实现不同

synchronized 是 JVM 层面通过监视器（Monitor）实现的，而 ReentrantLock 是通过 AQS（AbstractQueuedSynchronizer）程序级别的 API 实现。
synchronized 通过监视器实现，可通过观察编译后的字节码得出结论，如下图所示：

其中 monitorenter 表示进入监视器，相当于加锁操作，而 monitorexit 表示退出监视器，相当于释放锁的操作。
ReentrantLock 是通过 AQS 实现，可通过观察 ReentrantLock 的源码得出结论，核心实现源码如下：

小结

synchronized 和 ReentrantLock 都是 Java 中提供的可重入锁，二者的主要区别有以下 5 个：

1. 用法不同：synchronized 可以用来修饰普通方法、静态方法和代码块，而 ReentrantLock 只能用于代码块。
2. 获取锁和释放锁的机制不同：synchronized 是自动加锁和释放锁的，而 ReentrantLock 需要手动加锁和释放锁。
3. 锁类型不同：synchronized 是非公平锁，而 ReentrantLock 默认为非公平锁，也可以手动指定为公平锁。
4. 响应中断不同：ReentrantLock 可以响应中断，解决死锁的问题，而 synchronized 不能响应中断。
5. 底层实现不同：synchronized 是 JVM 层面通过监视器实现的，而 ReentrantLock 是基于 AQS 实现的。

快捷键

1.ctrl  alt v

2. ctrl f12 看本类的方法

3.按alt  enter  对报错的有奇用

4.ctrl win 箭头 桌面进行滑动

5.ctrl alt t  生成各种语句try catch   if while等