Java笔记之集合、多线程和动态代理

╰半橙微兮° 2022-02-24 06:18 115阅读 0赞

**一、ArrayList、LinkedList和Vector**

ArrayList和Vector都是基于数组实现的动态数组，而LinkedList是基于链表实现的集合，学过数据结构，我们都知道使用数据来检索元素的时间复杂度是O（1），而链表增删的时间复杂度是O（1），因此随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针，新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。另外，ArrayList属于非线程安全，而Vector则属于线程安全。**如果开发中没有线程同步的需求，推荐优先使用ArrayList**，因为其内部没有synchronized，执行效率会比Vector快很多。

**二、HashMap和HashTable**

HashMap是由**Entry数组**加**链表**的形式组成的，其中链表是为了解决hash冲突。

HashMap也存在缺点，在多线程的情况下，可能会形成死循环链表，当线程一要对数组进行扩容时，线程二先对Entry数组扩容了，此时数组角标对应的链表的顺序也会发生变化（A-B-NULL变成B-A-NULL），然后线程一也会进行类似的操作（B-A-NULL变成A-B-NULL），此时就变成了B.next = A，A.next = B，形成死循环。

那么对于HashTable，它对每个操作都加了synchronized，会对每一个拥有当前锁对象的线程上锁，其他线程在等待队列，无法进行操作。但这也造成了当有大量线程时HashMap效率低下的问题。

**三、HashSet和TreeSet**

HashSet是基于HashMap实现的，保存的数据是无序的，而TreeSet保存的数据是有序且不允许重复的。

**四、synchronized、volatile、Lock、ReentrantLock**

我们知道，并发编程存在一些问题：**上下文切换**、**死锁**和**资源限制**。

首先我们了解一下时间片，它是CPU分配给各个线程的时间，非常短，一般几十毫秒，通过切换现成的执行，从当前任务执行一个时间片后切换到下一个任务，并在切换前保存上一个任务的状态，这就叫上下文切换。

synchronized是一个关键字，修饰的方法或者代码块（保证可见性和排他性），它的实现是基于进入和退出 Monitor 对象实现，无论是显式同步（有明确的 **monitorenter **和 **monitorexit **指令，即同步代码块）还是隐式同步都是如此。同步方法并不是由 monitorenter 和 monitorexit 指令来实现的，而是由方法调用指令读取运行时常量池中方法的**ACC\_SYNCHRONIZED **标志来隐式实现的。

volatile修饰变量（保证可见性），有volatile修饰的共享变量进行写操作时，会有Lock前缀指令，**将当前处理器缓存行的数据写回到系统内存**，这个写回内存的操作会使**其他CPU里缓存了该内存地址的数据无效**。

Lock是一个接口，接口实现提供了比使用synchronized方法和语句可获得的更广泛的锁定操作。此实现允许更灵活的结构，可以具有差别很大的属性，可以支持多个相关的Condition对象（将Object监视器方法wait、notify 和 notifyAll，分解成截然不同的对象，以便通过将这些对象与任意 Lock实现组合使用），在硬件层面依赖特殊的CPU指令实现同步更加灵活。有**tryLock()**、**tryLock(long time, TimeUnit unit)**判断锁对象是否释放，**但必须在finally中释放锁，不然容易造成线程死锁**。

ReentrantLock是可重入锁，如果当前线程t1通过调用lock方法获取了锁之后，**再次调用lock，是不会再阻塞去获取锁的**，直接增加重入次数就行了。与每次lock对应的是unlock，unlock会减少重入次数，重入次数减为0才会释放锁。

**五、动态代理**

代理是一种常用的设计模式，其目的就是为其他对象提供一个代理以控制对某个对象的访问。代理类负责为委托类预处理消息，过滤消息并转发消息，以及进行消息被委托类执行后的后续处理。

在Java中要想实现动态代理机制，需要**java.lang.reflect.InvocationHandler**接口和 **java.lang.reflect.Proxy **类的支持：

//Object proxy:被代理的对象
    //Method method:要调用的方法
    //Object[] args:方法调用时所需要参数
    public interface InvocationHandler {
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
    }
    
    //CLassLoader loader:类的加载器
    //Class<?> interfaces:得到全部的接口
    //InvocationHandler h:得到InvocationHandler接口的子类的实例
    public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException
    
    public class UserManagerImpl implements UserManager {
     
      @Override
      public void addUser(String userId, String userName) {
        System.out.println("UserManagerImpl.addUser");
      }
     
      @Override
      public void delUser(String userId) {
        System.out.println("UserManagerImpl.delUser");
      }
     
      @Override
      public String findUser(String userId) {
        System.out.println("UserManagerImpl.findUser");
        return "张三";
      }
     
      @Override
      public void modifyUser(String userId, String userName) {
        System.out.println("UserManagerImpl.modifyUser");
     
      }
     
    }
    
    //动态代理类只能代理接口（不支持抽象类），代理类都需要实现InvocationHandler类，实现invoke方法。该invoke方法就是调用被代理接口的所有方法时需要调用的，该invoke方法返回的值是被代理接口的一个实现类
       
    public class LogHandler implements InvocationHandler {
     
      // 目标对象
      private Object targetObject;
      //绑定关系，也就是关联到哪个接口（与具体的实现类绑定）的哪些方法将被调用时，执行invoke方法。            
      public Object newProxyInstance(Object targetObject){
        this.targetObject=targetObject;
        //该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例  
        //第一个参数指定产生代理对象的类加载器，需要将其指定为和目标对象同一个类加载器
        //第二个参数要实现和目标对象一样的接口，所以只需要拿到目标对象的实现接口
        //第三个参数表明这些被拦截的方法在被拦截时需要执行哪个InvocationHandler的invoke方法
        //根据传入的目标返回一个代理对象
        return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),
            targetObject.getClass().getInterfaces(),this);
      }
      @Override
      //关联的这个实现类的方法被调用时将被执行
      /*InvocationHandler接口的方法，proxy表示代理，method表示原对象被调用的方法，args表示方法的参数*/
      public Object invoke(Object proxy, Method method, Object[] args)
          throws Throwable {
        System.out.println("start-->>");
        for(int i=0;i<args.length;i++){
          System.out.println(args[i]);
        }
        Object ret=null;
        try{
          /*原对象方法调用前处理日志信息*/
          System.out.println("satrt-->>");
          
          //调用目标方法
          ret=method.invoke(targetObject, args);
          /*原对象方法调用后处理日志信息*/
          System.out.println("success-->>");
        }catch(Exception e){
          e.printStackTrace();
          System.out.println("error-->>");
          throw e;
        }
        return ret;
      }
     
    }

动态代理与静态代理相比较，最大的好处是接口中声明的所有方法都被转移到调用处理器一个集中的方法中处理（InvocationHandler.invoke）。这样，在接口方法数量比较多的时候，我们可以进行灵活处理，而不需要像静态代理那样每一个方法进行中转。而且动态代理的应用使我们的类职责更加单一，复用性更强。

下面是一个ArrayList的动态代理：

import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    import java.util.List;
    import java.util.ArrayList;
    public class ArrayListProxy {
    
        public static void main(String args []){
            final List<String> list = new ArrayList<String>();
            List<String> proxyInstance = (List <String>) Proxy.newProxyInstance(list.getClass().getClassLoader(),
                    list.getClass().getInterfaces(), new InvocationHandler() {
                        @Override
                        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                            return method.invoke(list,args);
                        }
                    });
            proxyInstance.add("Hello word!");
            System.out.println(list);
        }
    
    }

在Spring中的核心思想AOP就是基于动态代理实现的。