字符串广泛应用在java编程中 在java中字符串属于对象  而且提供了string类来创建和操作字符串如何创建一个字符串呢？ string str="xiannbenxian";在代码中遇到字符串常量时 这里的赋值为"xiannbenxian",编译器会使用该值创建一个对象 如何用构造方法创建字符串呢？string strr2=new string("xiannbenxian")；string创建的字符串存储在公共池中 而new 创建的字符串string对象在堆上面 这是二者的区别；string s1="xiannbenxian";string s2="xiannbenxian";string s3=s1;string s4=new string("xiannbenxian");string s5=new string("xiannbenxian");这里面s1和s2是直接创建  s3中相同引用 s4和s5是字符串string对象创建 string类有11种构造方法 这些方法提供的不同的参数来初始化字符串 比如提供一个字符数组参数：2：如何像c语言使得俩个字符串连接在一起呢？方法1：string1.concat(string2);意义：返回string2连接string1的新字符串，也可以对字符串常量使用concat()方法 例："我叫仙女本仙".concat("哇")；更常用的是使用'+'操作来连接字符串， "hello，"+"java"+"!"输出：hello，java!例子：3：如何创建格式化字符串呢？举个例子 我们知道输出格式化数字可以使用print()和format()方法，string类使用静态方法format()返回一个string对象而不是printstram对象。              string类的静态方法 format()能用来创建可复用的格式化字符串，而不是仅仅用于一次打印输出例如：也可以等价换成：

    首先搭建idea中所需要的maven环境    查看maven环境是否搭建成功    写测试代码(openstack4Test和jcloudTest)，测试是否可以和虚拟机连接成功    运行openstack4测试方法是否成功    运行jcloud测试方法测试是否连接成功    连接虚拟机成功后先写一个index页面作为登录页面    编辑配置文件application.yml文件    首先搭建idea中所需要的maven环境    查看maven环境是否搭建成功    写测试代码(openstack4Test和jcloudTest)，测试是否可以和虚拟机连接成功    运行openstack4测试方法是否成功    运行jcloud测试方法测试是否连接成功    连接虚拟机成功后先写一个index页面作为登录页面    编辑配置文件application.yml文件    首先搭建idea中所需要的maven环境    查看maven环境是否搭建成功    写测试代码(openstack4Test和jcloudTest)，测试是否可以和虚拟机连接成功    运行openstack4测试方法是否成功    运行jcloud测试方法测试是否连接成功    连接虚拟机成功后先写一个index页面作为登录页面    编辑配置文件application.yml文件    首先搭建idea中所需要的maven环境    查看maven环境是否搭建成功    写测试代码(openstack4Test和jcloudTest)，测试是否可以和虚拟机连接成功    运行openstack4测试方法是否成功    运行jcloud测试方法测试是否连接成功    连接虚拟机成功后先写一个index页面作为登录页面    编辑配置文件application.yml文件    创建一个controller包，在controller包里创建一个类，让这个类首先实现到login页面的跳转    测试是否可以跳转到登录页面    在类里实现login连接到远程虚拟机上，同时在po包里创建实体类。代码功能在截图里进行介绍。

注意：重置密钥时，除了密钥与id改变，其余都不变API接口Demo：https://support.huaweicloud.com/devg-IoT/iot_02_3002.html参考网址：https://huaweicloud.blog.csdn.net/article/details/103934131

项目名称：浙江金华智慧花园项目问题描述：在公有云的ROMA(https://studioroma.e.huawei.com/roma/#/)下存在javax.crypto.spec.SecretKeySpec能够正常import，然而到了现场的私有云环境上述类无法import。截图为现场的私有云环境的现象。

STL中的容器：deque容器的常用接口及用法：deque：它被称作双端数组，可以在头部和尾部插入或删除数据；deque 容器和 vector 容器的区别：1.vector 容器对头部插入、删除数据的效率较低，因为 vector 容器是单端数组，若要从头部插入或删除，得把后面的数据都往后挪或往前挪，因此数据量越大，则其时间效率越低；2.deque 容器相对 vector 容器而言，它对于头部插入数据或头部删除数据的效率就高多了，这与它的内部实现相关；3.vector 容器访问单个数据的效率要高于 deque 容器，原因也是与 deque 容器的内部实现有关；图片转自于黑马程序员，是在学习的过程中截图下来的deque 容器内部工作原理：1.deque 内部有个中控器，它维护着每段缓冲区中的内容，而缓冲区里面放着真实的数据；2.中控器维护的其实是缓冲区的地址，使得使用 deque 容器时像一段连续的内存空间；3.缓冲区的头和尾是没有插满数据的，因此可以继续添加。添加满后，则会开辟一块新的缓冲区，中控器则记录下新的缓冲区的地址；4.由于中控器维护的是地址，因此当我们访问单个元素时，内部的实现是从地址再转到缓冲区，这里的时间效率就低于 vector 容器了；

四、线程池Q: ThreadPoolExecutor线程池构造参数中，corePoolSize和maximumPoolSize有什么区别？A：当提交新线程到池中时如果当前线程数 < corePoolSize，则会创建新线程如果当前线程数=corePoolSize，则新线程被塞进一个队列中等待。如果队列也被塞满了，那么又会开始新建线程来运行任务，避免任务阻塞或者丢弃如果队列满了的情况下， 线程总数超过了maxinumPoolSize，那么就抛异常或者阻塞（取决于队列性质）。调用prestartCoreThread()可提前开启一个空闲的核心线程调用prestartAllCoreThreads()，可提前创建corePoolSize个核心线程。Q： 线程池的keepalive参数是干嘛的？A：当线程数量在corePoolSize到maxinumPoolSize之间时， 如果有线程已跑完，且空闲时间超过keepalive时，则会被清除（注意只限于corePoolSize到maxinumPoolsize之间的线程）Q： 线程池有哪三种队列策略？A：握手队列相当于不排队的队列。可能造成线程数量无限增长直到超过maxinumPoolSize（相当于corePoolSize没什么用了，只以maxinumPoolSize做上限）无界队列队列队长无限，即线程数量达到corePoolSize时，后面的线程只会在队列中等待。（相当于maxinumPoolSize没什么用了）缺陷： 可能造成队列无限增长以至于OOM有界队列Q： 线程池队列已满且maxinumPoolSize已满时，有哪些拒绝策略？A：AbortPolicy 默认策略：直接抛出RejectedExecutionException异常DiscardPolicy 丢弃策略： 直接丢了，什么错误也不报DiscardOldestPolicy 丢弃队头策略： 即把最先入队的人从队头扔出去，再尝试让该任务进入队尾（队头任务内心：不公平。。。。）CallerRunsPolicy 调用者处理策略： 交给调用者所在线程自己去跑任务（即谁调用的submit或者execute，他就自己去跑）也可以用实现自定义新的RejectedExecutionHandlerQ：有以下五种Executor提供的线程池，注意记忆一下他们的用途，就能理解内部的原理了。newCachedThreadPool： 缓存线程池corePoolSize=0, maxinumPoolSize=+∞，队列长度=0 ，因此线程数量会在corePoolSize到maxinumPoolSize之间一直灵活缓存和变动， 且不存在队列等待的情况，一来任务我就创建，用完了会释放。newFixedThreadPool ：定长线程池corePoolSize= maxinumPoolSize=构造参数值， 队列长度=+∞。因此不存在线程不够时扩充的情况newScheduledThreadPool :定时器线程池提交定时任务用的，构造参数里会带定时器的间隔和单位。 其他和FixedThreadPool相同，属于定长线程池。newSingleThreadExecutor : 单线程池corePoolSize=maxinumPoolSize=1， 队列长度=+∞，只会跑一个任务， 所以其他的任务都会在队列中等待，因此会严格按照FIFO执行newWorkStealingPool（继承自ForkJoinPool ）： 并行线程池如果你的任务执行时间很长，并且里面的任务运行并行跑的，那么他会把你的线程任务再细分到其他的线程来分治。ForkJoinPool介绍：https://blog.csdn.net/m0_37542889/article/details/92640903Q： submit和execute的区别是什么？A:execute只能接收Runnable类型的任务，而submit除了Runnable，还能接收Callable（Callable类型任务支持返回值）execute方法返回void， submit方法返回FutureTask。异常方面， submit方法因为返回了futureTask对象，而当进行future.get()时，会把线程中的异常抛出，因此调用者可以方便地处理异常。（如果是execute，只能用内部捕捉或者设置catchHandler）Q：线程池中， shutdown、 shutdownNow、awaitTermination的区别？A：shutdown: 停止接收新任务，等待所有池中已存在任务完成（ 包括等待队列中的线程 ）。异步方法，即调用后马上返回。shutdownNow: 停止接收新任务，并 停止所有正执行的task，返回还在队列中的task列表 。awaitTermination： 仅仅是一个判断方法，判断当前线程池任务是否全部结束。一般用在shutdown后面，因为shutdown是异步方法，你需要知道什么时候才真正结束。五、Thread状态转换Q： 线程的6种状态是：A：New： 新建了线程，但是还没调用startRUNNABLE： 运行， 就绪状态包括在运行态中BLOCKED： 阻塞，一般是因为想拿锁拿不到WAITING： 等待，一般是wait或者join之后TIMED_WAITING: 定时等待，即固定时间后可返回，一般是调用sleep或者wait(时间)的。TERMINATED： 终止状态。欣赏一幅好图，能了解调用哪些方法会进入哪些状态。Q： java线程什么时候会进入阻塞（可能按多选题考）：A：sleepwati()挂起， 等待获得别的线程发送的Notify（）消息等待IO等待锁六、Volatile用volatile修饰成员变量时， 一旦有线程修改了变量，其他线程可立即看到改变。Q： 不用volatile修饰成员变量时， 为什么其他线程会无法立即看到改变？A：线程可以把变量保存在本地内存（比如机器的寄存器）中，而不是直接在主存中进行读写。这就可能造成一个线程在主存中修改了一个变量的值，而另外一个线程还继续使用它在寄存器中的变量值。Q： 用了volatile是不是就可以不用加锁啦？A： 不行。锁并不是只保证1个变量的互斥， 有时候是要保证几个成员在连续变化时，让其他线程无法干扰、读取。而volatile保证1个变量可变， 保证不了几个变量同时变化时的原子性。Q:展示一段《Java并发编程实战》书里的一个经典例子，在科目二考试里也出现了，只是例子换了个皮。为什么下面这个例子可能会死循环，或者输出0？:首先理解一下java重排序，可以看一下这篇博文：https://www.cnblogs.com/coshaho/p/8093944.html然后分析后面那2个奇怪的情况是怎么发生的。永远不输出：经过程序的指令排序，出现了这种情况：ReaderThread在while里读取ready值， 此时是false， 于是存入了ReaderThread的寄存器。主线程修改ready和number。ReaderThread没有感知到ready的修改（对于ReaderThread线程，感知不到相关的指令，来让他更新ready寄存器的值），因此进入死循环。输出0经过程序的指令排序，出现了这种情况：1）主线程设置ready为true2）ReaderThread在while里读取ready值，是true，于是退出while循环ReaderThread读取到number值， 此时number还是初始化的值为0，于是输出0主线程这时候才修改number=42，此时ReaderThread已经结束了！上面这个问题，可以用volatile或者加锁。当你加了锁时， 如果变量被写了，会有指令去更新另一个寄存器的值，因此就可见了。七、线程群组为了方便管理一批线程，我们使用ThreadGroup来表示线程组，通过它对一批线程进行分类管理使用方法：Thread group = new ThreadGroup("group");Thread thread = new Thread(gourp, ()->{..});即thread除了Thread(Runable)这个构造方法外，还有个Thread(ThreadGroup, Runnable)构造方法Q：在线程A中创建线程B， 他们属于同一个线程组吗A：是的线程组的一大作用是对同一个组线程进行统一的异常捕捉处理，避免每次新建线程时都要重新去setUncaghtExceptionHandler。即线程组自身可以实现一个uncaughtException方法。ThreadGroup group = new ThreadGroup("group") {    @Override    public void uncaughtException(Thread thread, Throwable throwable) {        System.out.println(thread.getName() + throwable.getMessage());        }    };}线程如果抛出异常，且没有在线程内部被捕捉，那么此时线程异常的处理顺序是什么？相信很多人都看过下面这段话，好多讲线程组的博客里都这样写：（1）首先看看当前线程组（ThreadGroup）有没有父类的线程组，如果有，则使用父类的UncaughtException()方法。（2）如果没有，就看线程是不是调用setUncaughtExceptionHandler()方法建立Thread.setUncaughtExceptionHandler实例。如果建立，直接使用它的UncaughtException()方法处理异常。（3）如果上述都不成立就看这个异常是不是ThreadDead实例，如果是，什么都不做，如果不是，输出堆栈追踪信息（printStackTrace）。来源：https://blog.csdn.net/qq_43073128/article/details/90597006https://blog.csdn.net/qq_43073128/article/details/88280469好，别急着记，先看一下下面的题目，问输出什么：Q:// 父类线程组static class GroupFather extends ThreadGroup {    public GroupFather(String name) {        super(name);    }    @Override    public void uncaughtException(Thread thread, Throwable throwable) {        System.out.println("groupFather=" + throwable.getMessage());    }} public static void main(String[] args) {    // 子类线程组    GroupFather groupSon = new GroupFather("groupSon") {        @Override        public void uncaughtException(Thread thread, Throwable throwable) {            System.out.println("groupSon=" + throwable.getMessage());        }    };    Thread thread1 = new Thread(groupSon, ()->{        throw new RuntimeException("我异常了");    });    thread1.start();}A：一看（1），那是不是应该输出groupFather?错错错，输出的是groupSon这句话在很多地方能看到，但没有去实践过看过源码的人就会这句话被误导。实际上父线程组不是指类继承关系上的线程组，而是指下面这样的：即指的是构造关系的有父子关系。如果子类的threadGroup没有去实现uncaughtException方法，那么就会去构造参数里指定的父线程组去调用方法。Q： 那我改成构造关系上的父子关系，下面输出什么？public static void main(String[] args) {    // 父线程组    ThreadGroup groupFather = new ThreadGroup("groupFather") {        @Override        public void uncaughtException(Thread thread, Throwable throwable) {            System.out.println("groupFather=" + throwable.getMessage());        }    };     // 子线程组,把groupFather作为parent参数    ThreadGroup groupSon = new ThreadGroup(groupFather, "groupSon") {        @Override        public void uncaughtException(Thread thread, Throwable throwable) {            System.out.println("groupSon=" + throwable.getMessage());        }    };     Thread thread1 = new Thread(groupSon, ()->{        throw new RuntimeException("我异常了");    });     thread1.start();}A：答案输出即只要子线程组有实现过，则会用子线程组里的方法，而不是直接去找的父线程组！Q：如果我让自己做set捕捉器的操作呢？那下面这个输出什么？public static void main(String[] args) {    // 父线程组    ThreadGroup group = new ThreadGroup("group") {        @Override        public void uncaughtException(Thread thread, Throwable throwable) {            System.out.println("group=" + throwable.getMessage());        }    };     // 建一个线程，在线程组内    Thread thread1 = new Thread(group, () -> {        throw new RuntimeException("我异常了");    });     // 自己设置setUncaughtExceptionHandler方法    thread1.setUncaughtExceptionHandler((t, e) -> {        System.out.println("no gourp:" + e.getMessage());    });     thread1.start();}A:看之前的结论里，似乎是应该输出线程组的异常？但是结果却输出的是：也就是说，如果线程对自己特地执行过setUncaughtExceptionHandler，那么有优先对自己设置过的UncaughtExceptionHandler做处理。那难道第（2）点这个是错的吗？确实错了，实际上第二点应该指的是全局Thread的默认捕捉器，注意是全局的。实际上那段话出自ThreadGroup里uncaughtException的源码：这里就解释了之前的那三点，但是该代码中没考虑线程自身设置了捕捉器所以修改一下之前的总结一下线程的实际异常抛出判断逻辑：如果线程自身有进行过setUncaughtExceptionHandler,则使用自己设置的按个。如果没设置过，则看一下没有线程组。并按照以下逻辑判断:如果线程组有覆写过uncaughtException，则用覆写过的uncaughtException如果线程组没有覆写过，则去找父线程组（注意是构造体上的概念）的uncaughtException方法。如果线程组以及父类都没覆写过uncaughtException， 则判断是否用Thread.setDefaultUncaughtExceptionHandler(xxx)去设置全局的默认捕捉器，有的话则用全局默认如果不是ThreadDeath线程， 则只打印堆栈。如果是ThreadDeath线程，那么就什么也不处理。

二、synchronized关键字即可作为方法的修饰符，也可以作为代码块的修饰符注意修饰方法时，并不是这个方法上有锁， 而是调用该方法时，需要取该方法所在对象上的锁。class A{     synchroized f(){     }   }即调用这个f()， 并不是说f同一时刻只能进入一次，而是说进入f时，需要取到A上的锁。Q： 调用下面的f()时，会出现死锁吗？class A{     synchroized f(){        t()     }      synchroized t(){     }}A：不会。1个线程内， 可以重复进入1个对象的synchroized 块。原理：当线程请求自己的锁时。JVM会记下锁的持有者，并且给这个锁计数为1。如果该线程再次请求自己的锁，则可以再次进入，计数为2。退出时计数-1，直到全部退出时才会释放锁。Q:2个线程同时调用f1和f2会产生同步吗？class A{    private static synchronized void f1(){};    private synchronized void f2(){};}A:不会产生同步。二者不是1个锁。f1是类锁，等同于synchronized(A.class)f2是对象锁。三、其他的同步工具CountDownLatchfinal CountDownLatch latch = new CountDownLatch(2);2是计数器初始值。然后执行latch.await()时， 就会阻塞，直到其他线程中把这个latch进行latch.countDown()，并且计数器降低至0。和join的区别：join阻塞时，是只等待单个线程的完成而CountDownLatch可能是为了等待多个线程Q： countDownLatch的内部计数值能被重置吗？A：不能重置了。如果要重新计数必须重新new一个。毕竟他的类名就叫DownLatchFutureTask可以理解为一个支持有返回值的线程FutureTask<Integer> task = new FutureTask<>(runable);当调用task.get()时，就能能达到线程里的返回值Q：调用futrueTask.get()时，这个是阻塞方法吗？如果是阻塞，什么时候会结束？A：是阻塞方法。线程跑完并返回结果阻塞时间达到futrueTask.get(xxx)里设定的xxx时间线程出现异常InterruptedException或者ExecutionException线程被取消，抛出CancellationExceptionSemaphore信号量：就是操作系统里常见的那个概念，java实现，用于各线程间进行资源协调。用Semaphore(permits)构造一个包含permits个资源的信号量，然后某线程做了消费动作， 则执行semaphore.acquire()，则会消费一个资源，如果某线程做了生产动作，则执行semaphore.release()，则会释放一个资源（即新增一个资源）更详细的信号量方法说明：https://blog.csdn.net/hanchao5272/article/details/79780045Q： 信号量中，公平模式和非公平模式的区别？下面设成true就是公平模式//new Semaphore(permits,fair):初始化许可证数量和是否公平模式的构造函数semaphore = new Semaphore(5, true);A：其实就是使用哪种公平锁还是非公平锁。Java并发中的fairSync和NonfairSync主要区别为：如果当前线程不是锁的占有者,则NonfairSync并不判断是否有等待队列,直接使用compareAndSwap去进行锁的占用,即谁正好抢到，就给谁用！如果当前线程不是锁的占有者,则FairSync则会判断当前是否有等待队列,如果有则将自己加到等待队列尾，即严格的先到先得！CyclicBarrier栅栏，一般是在线程中去调用的。它的构造需要指定1个线程数量，和栅栏被破坏前要执行的操作，每当有1个线程调用barrier.await()，就会进入阻塞，同时barrier里的线程计数-1。当线程计数为0时， 调用栅栏里指定的那个操作后，然后破坏栅栏， 所有被阻塞在await上的线程继续往下走。Exchanger我理解为两方栅栏，用于交换数据。简单说就是一个线程在完成一定的事务后，想与另一个线程交换数据，则第一个先拿出数据的线程会一直等待第二个线程，直到第二个线程拿着数据到来时才能彼此交换对应数据。原子类AtomicXXX就是内部已实现了原子同步机制Q：下面输出什么？（考察getAndAdd的用法）AtomicInteger num = new AtomicInteger(1);System.out.println(num.getAndAdd(1));System.out.println(num.get());A：输出1、2顾名思义， getAndAdd(),那么就是先get，再加， 类似于num++。如果是addAndGet()，那么就是++numQ：AtomicReference和AtomicInteger的区别？A：AtomicInteger是对整数的封装，而AtomicReference则对应普通的对象引用。也就是它可以保证你在修改对象引用时的线程安全性。即可能会有多个线程修改atomicReference里包含的引用。经典用法：boolean exchanged = atomicStringReference.compareAndSet(initialReference, newReference)就是经典的CAS同步法compreAndSet它会将将引用与预期值（引用）进行比较，如果它们相等，则在AtomicReference对象内设置一个新的引用。类似于一个非负责的自旋锁。AtomicReferenceArray是原子数组， 可以进行一些原子的数组操作例如 set(index, value)，java中已实现的全部原子类：注意，没有float，没有short和byte。

Q： 上题的suspend和resume可以怎么替换，来解决死锁问题？A： 可以用wait和noitfy来处理（不过尽量不要这样设计，一般都是用run内部带1个while循环的）public class Test {    public static Object lockObject = new Object(); //拿来做临时锁对象    public static void main(String[] args) throws InterruptedException {         Thread thread = new MyThread();        thread.start();        Thread.sleep(1000);         System.out.println("主线程试图占用lockObject锁资源");        synchronized (Test.lockObject) {            // 用Test.lockObject做一些事            System.out.println("做一些事");        }        System.out.println("恢复");         synchronized (Test.lockObject) {            Test.lockObject.notify();        }     }} class MyThread extends Thread {    public void run() {        try {            synchronized (Test.lockObject) {                System.out.println("占用Test.lockObject");                Test.lockObject.wait();            }            System.out.println("MyThread释放TestlockObject锁资源");        }        catch (Exception e){}    }}如此执行，结果正常：Q： 下面这例子为什么会运行异常，抛出IllegalMonitorStateException错误？    public static void main(String[] args) throws InterruptedException {        Thread thread = new MyThread();        thread.start();        thread.notify();    }A： notify和wait的使用前提是必须持有这个对象的锁， 即main代码块 需要先持有thread对象的锁，才能使用notify去唤醒（wait同理）。改成下面就行了：        Thread thread = new MyThread();        thread.start();        synchronized (thread) {            thread.notify();        }Q： Thread.sleep()和Object.wait()的区别A：sleep不会释放对象锁， 而wait会释放对象锁。Q：Runnable接口和Callable的区别。A： Callable可以和Futrue配合，并且启动线程时用的时call，能够拿到线程结束后的返回值，call方法还能抛出异常。Q：thread.alive()表示线程当前是否处于活跃/可用状态。活跃状态： 线程已经启动且尚未终止。线程处于正在运行或准备开始运行的状态，就认为线程是“存活的thread.start()后，是否alive()一定返回true？public class Main {    public static void main(String[] args) {        TestThread tt = new TestThread();        System.out.println("Begin == " + tt.isAlive());        tt.start();        System.out.println("end == " + tt.isAlive());    }}A:不一定，有可能在打印时，线程已经运行结束了，或者start后，还未真正启动起来（就是还没进入到run中）Q: 线程A如下：public class A extends Thread {    @Override    public void run() {        System.out.println("this.isAlive()=" + this.isAlive());    }}把线程A作为构造参数，传给线程BA a = new A();Thread b = new Thread(a);b.start()此时会打印什么？A：此时会打印false!因为把a作为构造参数传入b中， b执行start时， 实际上是在B线程中去调用了 A对象的run方法，而不是启用了A线程。如果改成A a = new A();a.start()那么就会打印true了Q：把FutureTask放进Thread中，并start后，会正常执行callable里的内容吗？public static void main(String[] args) throws Exception {    Callable<Integer> callable = () -> {    System.out.println("call 100");    return 100;    };     FutureTask<Integer> task = new FutureTask<>(callable);    Thread thread = new Thread(task);    thread.start();}A：能正常打印

多线程可以理解为在同一个程序中能够同时运行多个不同的线程来执行不同的任务，这些线程可以同时利用CPU的多个核心运行。多线程编程能够最大限度的利用CPU的资源。本文将通过以下几个方向为大家讲解多线程的用法。1.Thread类基础2.synchronized关键字3.其他的同步工具CountDownLatchFutureTaskSemaphoreCyclicBarrierExchanger原子类AtomicXXX4.线程池5.Thread状态转换6.Volatile7.线程群组一、Thread类基础Q： Thread的deprecated过期方法是哪3个？作用是啥A：stop()， 终止线程的执行。suspend()， 暂停线程执行。resume()， 恢复线程执行。Q： 废弃stop的原因是啥？A：调用stop时，会直接终止线程并释放线程上已锁定的锁，线程内部无法感知，并且不会做线程内的catch操作！即线程内部不会处理stop后的烂摊子。如果其他线程等在等着上面的锁去取数据， 那么拿到的可能是1个半成品。变成题目的话应该是下面这样，问会输出什么？public class Test {     public static void main(String[] args) throws InterruptedException {         System.out.println("start");        Thread thread = new MyThread();        thread.start();        Thread.sleep(1000);        thread.stop();        // thread.interrupt();     }} class MyThread extends Thread {    public void run() {        try {            System.out.println("run");            Thread.sleep(5000);        } catch (Exception e) {            //处理烂摊子,清理资源            System.out.println("clear resource!");        }    }}Q： stop的替代方法是什么？A： interrupt()。调用thread.interrupt()终止时， 不会直接释放锁，可通过调用interrupt()或者捕捉sleep产生的中断异常，来判断是否被终止，并处理烂摊子。上题把thread.stop()改成thread.interrupt()，在Thread.sleep()过程中就会抛出interrupException（注意，InterrupExcetpion是sleep抛出的）因此就会输出clear resource。如果没有做sleep操作， 可以用isInterrupted()来判断自己这个线程是否被终止了，来做清理。另外注意一下interrupt和isInterrupted的区别：Q： suspend/resume的废弃原因是什么？A： ：调用suspend不会释放锁。如果线程A暂停后，他的resume是由线程B来调用的，但是线程B又依赖A里的某个锁，那么就死锁了。例如下面这个例子，就要知道会引发死锁：public class Test {    public static Object lockObject = new Object();    public static void main(String[] args) throws InterruptedException {         System.out.println("start");        Thread thread = new MyThread();        thread.start();        Thread.sleep(1000);         System.out.println("主线程试图占用lockObject锁资源");        synchronized (Test.lockObject) {            // 用Test.lockObject做一些事            System.out.println("做一些事");        }        System.out.println("恢复");        thread.resume();     }} class MyThread extends Thread {    public void run() {        try {            synchronized (Test.lockObject) {                System.out.println("占用Test.lockObject");                suspend();            }            System.out.println("MyThread释放TestlockObject锁资源");        }        catch (Exception e){}    }}答案输出MyThread内部暂停后，外部的main因为没法拿到锁，所以无法执行后面的resume操作。

Connection.setAutoCommit(boolean)用于事务提交。setAutoCommit（true）， 则执行的所有sql执行都会作为单个事务直接提交并运行setAutoCommit（false）， 则必须等调用conn.commit(）才会提交运行Q： setAutoCommit默认是true还是falseA： 默认是true。Q： setAutoCommit（true）的缺点是什么？A： 如果一次性执行多个sql语句， 中间sql出错时，就会造成脏数据。Q： setAutoCommit(false)后，如果出了错却没有在catch中进行Connection的rollBack操作，会发生什么？A; 操作的表就会被锁住，造成数据库死锁fetchSizefetchSize 是设定JDBC的Statement读取数据的时候每次从数据库中取出的记录条数fetchSize越 大， 客户端内存占用越 大，读取数据库次数越 少，速度越 快。Q： Oracle和Mysql中的fetchSize有什么区别？A： Oracle会每次网络传输fetchSize条数据到客户端， MYSQL则会一次性全部传送到客户端，因此Mysql中的fetchSize是一种模拟游标。PreparedStatementQ：相比Statement的好处？A：PreparedStatement是预编译的，比Statement速度快，执行效率高，因此即使sql中不带参数也最好使用PreparedStatement代码的可读性和可维护性更好(相比于sql拼接）PreparedStatement可以防止SQL注入攻击，而Statement却不能Q：prepareStatement是statement接口的实现吗？A：prepareStatement不是实现，而是继承的接口CallableStatementCallableStatement继承自PreparedStatementCallableStatement接口添加了 调用存储过程 核函数以及处理输出参数(INOUT)的方法。即存储过程就用CallableStatementConnection Pool连接池优点：减少连接创建次数更快的系统整体响应速度统一连接管理，减少失误性的连接未关闭。ResultSet作用： 缓存数据结果集Statement st = conn. createStatement (int resultSetType, int resultSetConcurrency) ResultSet rs = st.executeQuery(sqlStr)滚动，就是指调用.next()或者.previous()或者移动到对应行resultSetType 是设置 ResultSet 对象的类型可滚动，或者是不可滚动。取值如下（见单词知意）：ResultSet.TYPE_FORWARD_ONLY 只能向前滚动ResultSet.TYPE_SCROLL_INSENSITIVE, 支持前后滚动，对修改不敏感ResultSet.TYPE_SCROLL_SENSITIVE 支持前后滚动，对修改敏感resultSetConcurency 是设置 ResultSet 对象能够修改的，取值如下：ResultSet.CONCUR_READ_ONLY 设置为只读类型的参数。ResultSet.CONCUR_UPDATABLE 设置为可修改类型的参数。Q:Connection、statement、ResultSet的关闭顺序是？A：先ResultSet、再Statement、最后再connection。因为这种操作很麻烦，最好使用jdbc连接池，或者try-with-resource数据库知识Q：事务的ACID属性是什么？A：A是 atomicity原子性, 事务内的行为一次性执行完，要么就回退C是consistency一致性 有a+b=c的限制条件，然后a变化的同时，b也必须跟着变化I是isolation隔离性 事务隔离，即事务的中间执行过程，对另外一个事务不可见。D是durability持久性 提交i成功后，修改不会改变，也会被记录。Q： 脏读、不可重复读和幻读是什么？A：脏读：数据被更新了，但是还没提交， 然后另一个事务读到了更新后的数据，结果事务回滚了，导致读的数据其实是脏数据，不可重复读： 1个事务要读2次数据（注意是单条数据），结果第一次读和第二次读数据不一致了。幻读： 1个事务读了2次 数据，发现2次的记录数不一致（注意事项记录数）————————————————

Connection.setAutoCommit(boolean)用于事务提交。setAutoCommit（true）， 则执行的所有sql执行都会作为单个事务直接提交并运行setAutoCommit（false）， 则必须等调用conn.commit(）才会提交运行Q： setAutoCommit默认是true还是falseA： 默认是true。Q： setAutoCommit（true）的缺点是什么？A： 如果一次性执行多个sql语句， 中间sql出错时，就会造成脏数据。Q： setAutoCommit(false)后，如果出了错却没有在catch中进行Connection的rollBack操作，会发生什么？A; 操作的表就会被锁住，造成数据库死锁fetchSizefetchSize 是设定JDBC的Statement读取数据的时候每次从数据库中取出的记录条数fetchSize越 大， 客户端内存占用越 大，读取数据库次数越 少，速度越 快。Q： Oracle和Mysql中的fetchSize有什么区别？A： Oracle会每次网络传输fetchSize条数据到客户端， MYSQL则会一次性全部传送到客户端，因此Mysql中的fetchSize是一种模拟游标。PreparedStatementQ：相比Statement的好处？A：PreparedStatement是预编译的，比Statement速度快，执行效率高，因此即使sql中不带参数也最好使用PreparedStatement代码的可读性和可维护性更好(相比于sql拼接）PreparedStatement可以防止SQL注入攻击，而Statement却不能Q：prepareStatement是statement接口的实现吗？A：prepareStatement不是实现，而是继承的接口CallableStatementCallableStatement继承自PreparedStatementCallableStatement接口添加了 调用存储过程 核函数以及处理输出参数(INOUT)的方法。即存储过程就用CallableStatementConnection Pool连接池优点：减少连接创建次数更快的系统整体响应速度统一连接管理，减少失误性的连接未关闭。ResultSet作用： 缓存数据结果集Statement st = conn. createStatement (int resultSetType, int resultSetConcurrency) ResultSet rs = st.executeQuery(sqlStr)滚动，就是指调用.next()或者.previous()或者移动到对应行resultSetType 是设置 ResultSet 对象的类型可滚动，或者是不可滚动。取值如下（见单词知意）：ResultSet.TYPE_FORWARD_ONLY 只能向前滚动ResultSet.TYPE_SCROLL_INSENSITIVE, 支持前后滚动，对修改不敏感ResultSet.TYPE_SCROLL_SENSITIVE 支持前后滚动，对修改敏感resultSetConcurency 是设置 ResultSet 对象能够修改的，取值如下：ResultSet.CONCUR_READ_ONLY 设置为只读类型的参数。ResultSet.CONCUR_UPDATABLE 设置为可修改类型的参数。Q:Connection、statement、ResultSet的关闭顺序是？A：先ResultSet、再Statement、最后再connection。因为这种操作很麻烦，最好使用jdbc连接池，或者try-with-resource数据库知识Q：事务的ACID属性是什么？A：A是 atomicity原子性, 事务内的行为一次性执行完，要么就回退C是consistency一致性 有a+b=c的限制条件，然后a变化的同时，b也必须跟着变化I是isolation隔离性 事务隔离，即事务的中间执行过程，对另外一个事务不可见。D是durability持久性 提交i成功后，修改不会改变，也会被记录。Q： 脏读、不可重复读和幻读是什么？A：脏读：数据被更新了，但是还没提交， 然后另一个事务读到了更新后的数据，结果事务回滚了，导致读的数据其实是脏数据，不可重复读： 1个事务要读2次数据（注意是单条数据），结果第一次读和第二次读数据不一致了。幻读： 1个事务读了2次 数据，发现2次的记录数不一致（注意事项记录数）部分参考资料https://blog.csdn.net/u011543448/article/details/79441066

CodePecker1、 完全自主知识产权，全部由国内信息安全技术人员研发，避免了外国同类产品的安全隐患。目前本产品已获得软件注册权登记证书6项，分别是《JAVA/JSP语言Codepecker源代码分析软件V1.0》（软著登字第0670475号）、《C/C++语言Codepecker源代码缺陷分析系统V1.0》（软著登字第1090327号）、《Python语言Codepecker源代码缺陷分析系统V1.0》（软著登字第1050911号）、《Python语言Codepecker源代码缺陷分析系统V2.0》（软著登字第1090900号）、《PHP语言Codepecker源代码缺陷分析系统V1.0》（软著登字第1031250号）、《PHP语言Codepecker源代码缺陷分析系统V2.0》（软著登字第1090899号）。2、 界面友好：CodePecker采用全中文界面，全程中文界面支持，无论是操作界面、支持的文件目录类型，还是输出的报告均为中文，大大提升了国内用户的使用方便程度，从而大幅提升了工作效率。而国外同类产品都是英文的，只能输出英文的报告，有些中文目录也无法支持。CodePecker在使用过程中，操作简单易用，不需要复杂的检测流程，检测结果简单明了，并有详细的缺陷分析，同时提供了缺陷分析的追踪定位，用户只需要简单的鼠标操作，就能够对缺陷传播定位。同时鉴于开发人员对信息安全知识的了解，在缺陷类型中会有详细的缺陷点评，即使开发人员不熟悉此缺陷类型，通过缺陷点评，也能迅速的了解掌握此类缺陷。3、实现了云计算平台（http://wwww.cloudcp.cn），CodePecker产品目前已经将云计算的理念很好的融合进来，可以实现云计算平台下运行。整个软件的操作界面可以实现Web方式，用户可以通过网页进行操作，B/S的方式可以将操作系统的影响降到最低，只要有一台可以上网的电脑和浏览器，无论什么操作系统都可以使用CodePecker远程进行源代码扫描，不会因为测试人员或是开发人员的电脑配置影响扫描速度，扫描的速度完全取决于主机的性能。而国外产品主要还是单机软件，虽然目前也在不断地向SaaS的方向进行过渡，但还没有成熟的产品或服务推向市场。4、符合国际标准，支持检测多种缺陷和质量类型：CodePecker团队成员有着多年的源码安全检测经验，依靠业内知名专业的安全团队的研究，CodePecker漏洞知识库已包含多种语言多达数百条缺陷类型，每条漏洞都有详尽的描述和修补建议，同时积极与国际化接轨，大部分缺陷类型都可以映射到CVE和OWASP等权威国际安全组织公布的缺陷分类中。缺陷类型涵盖了常见操作系统、数据库、Web工程和应用程序的绝大多数可以远程利用的漏洞以及本地安全漏洞。缺陷检测覆盖常见的多种语言、多种缺陷类别，包括跨站注入、Sql注入、拒绝服务等高危缺陷漏洞类型，也包括空指针引用，资源为释放、变量未初始化等代码质量缺陷类型。从多个维度全面覆盖代码安全问题，并积极更新最新研究结果和关注国内外最新安全研究动态，同步更新研究成果，保证缺陷知识库内容的覆盖广度和深度。5、高效快速的缺陷分析：通过优化的数据流分析技术、缺陷类型的智能识别、检测规则依赖关系等源码扫描技术的运用，再加上安全团队根据多年的源码检测经验和国内外安全信息缺陷结果，以及完善的缺陷检测规则，CodePecker缺陷检测软件在源码检测速度和检测结果的准确性做到了一个很好的平衡，既保证了检测的速度，又保证了缺陷检测的质量。6、低误报率和漏报率：采用业内领先的深度缺陷扫描分析技术，CodePecker软件对同样的目标系统进行检测时，能提供过程内（Intra-procedure）、过程间（Inter-procedure）等各种层次的分析，全面深入地开展缺陷检测，全面降低了检测结果中的误报率和漏报率，检测精度、准度高。7、可自定义的缺陷类型检测规则：系统本身提供了25个大类，169种的缺陷类型检测，用户可以根据具体的需求对被检测代码做一个全量分析，也可以根据业务需求，针对自己系统关心的缺陷进行定制检测。如在大型应用系统中，存在各系统中，存在各种级别的缺陷类型，检测结果可能偏多，会干扰错误排查，用户可只针对高危或者某几类类缺陷做有针对性的深度检测，只关注特定的缺陷类型，从而达到检测效果。

有些时候我们做某几件事情的步骤都差不多，仅有那么一小点的不同，在软件开发的世界里同样如此，如果我们都将这些步骤都一一做的话，费时费力不讨好。所以我们可以将这些步骤分解、封装起来，然后利用继承的方式来继承即可，当然不同的可以自己重写实现嘛！这就是模板方法模式提供的解决方案。所谓模板方法模式就是在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以在不改变算法结构的情况下，重新定义算法中的某些步骤。模板方法模式就是基于继承的代码复用技术的。在模板方法模式中，我们可以将相同部分的代码放在父类中，而将不同的代码放入不同的子类中。也就是说我们需要声明一个抽象的父类，将部分逻辑以具体方法以及具体构造函数的形式实现，然后声明一些抽象方法让子类来实现剩余的逻辑，不同的子类可以以不同的方式来实现这些逻辑。所以模板方法的模板其实就是一个普通的方法，只不过这个方法是将算法实现的步骤封装起来的。模板方法模式包含如下角色：AbstractClass: 抽象类 ConcreteClass: 具体子类

访问者模式俗称23大设计模式中最难的一个。除了结构复杂外，理解也比较难。在我们软件开发中我们可能会对同一个对象有不同的处理，如果我们都做分别的处理，将会产生灾难性的错误。对于这种问题，访问者模式提供了比较好的解决方案。访问者模式即表示一个作用于某对象结构中的各元素的操作，它使我们可以在不改变各元素的类的前提下定义作用于这些元素的新操作。访问者模式的目的是封装一些施加于某种数据结构元素之上的操作，一旦这些操作需要修改的话，接受这个操作的数据结构可以保持不变。为不同类型的元素提供多种访问操作方式，且可以在不修改原有系统的情况下增加新的操作方式。同时我们还需要明确一点那就是访问者模式是适用于那些数据结构比较稳定的，因为他是将数据的操作与数据结构进行分离了，如果某个系统的数据结构相对稳定，但是操作算法易于变化的话，就比较适用适用访问者模式，因为访问者模式使得算法操作的增加变得比较简单了。访问者模式包含如下角色：Vistor: 抽象访问者ConcreteVisitor: 具体访问者Element: 抽象元素ConcreteElement: 具体元素 ObjectStructure: 对象结构

代理模式就是给一个对象提供一个代理，并由代理对象控制对原对象的引用。它使得客户不能直接与真正的目标对象通信。代理对象是目标对象的代表，其他需要与这个目标对象打交道的操作都是和这个代理对象在交涉。代理对象可以在客户端和目标对象之间起到中介的作用，这样起到了的作用和保护了目标对象的，同时也在一定程度上面减少了系统的耦合度。代理模式包含如下角色： Subject: 抽象主题角色 Proxy: 代理主题角色 RealSubject: 真实主题角色