java基础回顾2

重载：发生在同一个类型中；方法名字相同；参数列表不同(类型，个数，顺序)

覆盖：发生在继承关系中，接口实现中；方法要一模一样，而且子类的方法的权限修饰符要比父类的大

ArrayList扩容机制  在jdk7.0之前是   *3/2+1   在jdk7.0开始就是 old+(old>>1)  ->1.5倍扩容

集合添加玩元素后    用trimToSize();将多余的空间舍去；

在iterator遍历ArrayList的过程中，不允许对集合整体进行任何元素的添加删除   会发生 ConcurrentModificationException(并发修改异常)；

多线程： 具备随机性   一个多线程  有哪个线程去执行时cpu的指定，是随机的  ；它提高了程序的效率，不必每次等一个代码执行完，后面的才开始执行；

进程：一个正在执行的程序就是一个进程    ，每一个进程都有一个执行顺序，该顺序是一个执行路径（控制单元），每个独立的控制单元就是一个线程；

jvm就是多线程的    一个启动  一个GC（垃圾回收器）

任意时刻，都只有一个程序在进行的工作，之所电脑可以运行多个进程（进程运行最终还是线程在执行），其实是cpu在各个线程之间快速切换，让你看上去在同事执行

多线程的实现方式：

1：extends Thread        覆盖run()方法；这个类.start()    它是Thread类存储运行线程的代码

2：implements Runnable   同样覆盖run();  然后将这个类 new Thread(这个类的对象).start()

线程的四种状态+特殊状态

多线程的存在就会出现安全问题  比如一个线程在使用一个资源 而这个资源处于临界状态  他通过了判断条件但是这个时候他被冻结了，停在这里，一个新的线程启动进来了，因为资源还没被使用，判断条件不变 ，它将资源用掉了 由于前面一个停在里面通过了判断条件 醒来之后继续执行结果产生错误(异常)

这时就需要锁  进去一个，在进去的那个没出来之前，其余的是进不去的 其实这样效率就变低，

同步代码块

synchronized(对象){   //这里的对象可以是任意的，一般就是object对象

   这里是被锁住的代码，

}

在单例设计模式的懒汉式中，会出现安全问题 这里给出解决办法

Single s=null;   //懒汉式一开始不需要

public static Single getInstance(){

if(s==null){    //这里判断,就不用锁每次都去判断

synchronized(Single.class){

if(s==null)      //如果一个线程停在这里   因为s一直没有被创建  所以s=null所以其余的线程根本不用锁来判断，

s=new Single();

}

}

return s;

}

同步函数   他的锁是this

public synchronized() { }

同步的前提：

1：多线程  2：多个线程一个锁

死锁 :两个线程  A B   A需要B现在拥有的锁才能继续下去B同样需要A的  这样互相需要  结果奔溃 死锁形成

等待唤醒机制：wat()   ;  notify();notifyAll()  这些都是Object的方法  因为这些方法是被对象调用，对象不确定所以是上帝的方法  但是这些方法是有缺点的   在多个线程的情况下  可能去自己唤醒自己这边的线程 这样会出现异常   所以有了  java.util.concurrent.locks提供了常用的接口和类   

lock比synchronized操作锁更加广泛 这是jdk1.5开始出现的  

Condition对象的出现和lock配合  condition中将object中的wait() notify()  notifyAll() 方法分解不同的对对象; await()  signal() signalAll()

可以更好地与lock配合

ReentrantLock lock=new ReentrantLock();

Condition con1=lock.newCondition();

Condition con2=lock.newCondition();

可以这样有两个对象  这样在唤醒的时候  1就唤醒2的  2就唤醒1的  这样既不会出现将自己这边的唤醒

守护线程 线程.setDaemn(true)     如果当所有的线程都是守护线程的情况下  jvm停止了  

临时加入线程  join()