JavaSE之代理和线程基础

最新推荐文章于 2022-05-10 11:18:04 发布

AlanHand

最新推荐文章于 2022-05-10 11:18:04 发布

阅读量782

点赞数

分类专栏： JavaSE 文章标签：实例线程线程安全 thread

本文链接：https://blog.csdn.net/AlanHand/article/details/39054275

版权

JavaSE 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

一：代理

1.代理的概念与作用

1.1.生活中的代理：

买电脑时可以从实体店买，也可以从电脑的本部去买，有区别吗？

当然有，你买电脑时会跑去电脑的本部买吗？你得先知道地点还得自己来回跑，多麻烦。

1.2.程序中的代理:

1.2.1.要为已存在的多个具有相同接口的目标类的各个方法增加一些系统功能，例如，异常处理、日志、计算方法的运行时间见等等。

1.2.2.编写一个与目标类具有相同接口的代理类，代理类的每个方法调用目标类的相同方法，并在调用方法时加上系统功能的方法。（请看原理图）。

1.2.3.如果采用工厂模式和配置文件的方式进行管理，则不需要修改客户端程序，在配置文件中配置是使用目标类、还是代理类，这样以后很容易切换。

例如：想要日志功能时就配置代理类，否则配置目标类，这样，增加系统功能很容易，以后运行一段时间后又想去掉系统功能也很容易。

2.动态代理技术：

2.1.要为系统中的各个接口的类增加代理功能，那将需要太多的代理类，全部采用静态代理方式将是一个非常麻烦的事情。

2.2.JVM可以再运行期动态生成出类的字节码，这种动态生成的类往往被用作代理类，即动态代理类。

2.3.JVM生成的动态代理类必须实现一个或多个接口，所以，JVM生成的动态类智能用作具有相同接口的目标类的代理。

2.4.CGLIB库可以动态生成一个类的子类，一个类的子类也可以用作该类的代理，so 如果要为一个没有实现接口的类生成动态代理类，那么可以使用CGLIB库。

2.5.代理类的各个方法中通常除了要调用目标类的相应方法和对外返回目标返回的结果外，还可以在代理方法中的如下四个位置加上系统功能代码。

2.5.1.在调用方法之前

2.5.2.在调用方法之前

2.5.3.在调用方法前后

2.5.4.在处理目标方法异常的catch块中

请看图解：

3.让动态生成的类成为目标类的代理

3.1.分析动态代理的工作原理图

3.2.怎样将目标类传进去？

3.2.1.直接在InvocationHandler实现类中创建目标类的实例对象，可以看运行效果和加入日志代码，但没有实际意义。

3.2.2.为InvocationHandler实现类注入目标类的实例对象，不能采用匿名内部类的形式了。

3.2.3.让匿名的InvocationHandler实现类访问外面方法中的目标类实例对象的final类型的引用变量。

3.3.将创建代理的过程改为一种更优雅的方式，Eclipse重构出一个getProxy方法绑定接收目标同时返回代理对象，让调用者更懒惰，更方便，调用者甚至不用接触任何代理的ＡＰＩ。

3.4.将系统功能代码模块化，即将切面代码也改为通过参数形式提供，怎样把要执行的系统功能代码以参数形式提供？

3.4.1.把要执行的代码装到一个对象的某个方法里，然后把这个对象作为参数传递，接收者只要调用这个对象的方法，即等于执行了外界提供的代码！

3.4.2为Bind方法增加一个Advice参数。

4.猜想一下动态代理类的内部代码

4.1.动态生成的类实现了Collection接口(可以实现若干接口)，生成的类有Collection接口中的所有方法和一个如下接受InvocationHandler参数的构造方法。

4.2.构造方法接受一个InvocationHandler，接受对象了要干什么用呢？该方法内部的代码回事怎样的呢？

4.3.实现Collection接口的动态类中的各个方法的代码又是怎样的呢？说明如下：

客户端程序调用某个代理类的方法时涉及三要素：

如objProxy.add("abc")方法:执行时会调用下面的方法

invoke(Object proxy,Method method,Object[] args);

objProxy -> proxy,

add -> method,

abc -> args.

请看图解：

示例代码如下：

1.定义一个Advice接口：

package com.JavaSE.Proxy;

import java.lang.reflect.Method;

public interface Advice {
	void beforeMethod(Method method);
	void afterMethod(Method method);
}

</pre><p><span style="font-size:18px"><strong>2.实现Advice接口的类：</strong></span></p><p></p><p><span style="font-family:Arial; line-height:26px"><span style="font-size:18px"></span></span></p><pre code_snippet_id="464081" snippet_file_name="blog_20140904_2_6660262" name="code" class="java">package com.JavaSE.Proxy;

import java.lang.reflect.Method;

public class MyAdvice implements Advice {
	long beginTime = 0;
	public void afterMethod(Method method) {
		System.out.println("上班啦！");		
		long endTime = System.currentTimeMillis();
		System.out.println(method.getName() + " running time of " + (endTime - beginTime));

	}
	public void beforeMethod(Method method) {
		System.out.println("下班啦！");
		beginTime = System.currentTimeMillis();
	}
}

3.代理测试类：

package com.JavaSE.Proxy;

import java.lang.reflect.Constructor;

public class ProxyTest {

	@SuppressWarnings({ "rawtypes", "unchecked", "unused" })//去掉警告
	public static void main(String[] args) throws Exception {
		//获取代理对象的字节码
		Class clazzProxy = Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class);
	    
		//获取代理对象的所有构造方法
		Constructor[] constructors = clazzProxy.getConstructors();
	        System.out.println("代理类的构造方法------------------------------");
	        for(Constructor constructor : constructors){//迭代构造方法，获取每个构造方法的参数类型
	    	StringBuilder sb = new StringBuilder(constructor.getName());
	    	sb.append('(');
	    	Class[] clazzParams = constructor.getParameterTypes();
	    	if(clazzParams !=null && clazzParams.length != 0){
	    		for(Class param : clazzParams){
	    			sb.append(param.getName());
	    			sb.append(',');
	    		}
	    		sb.deleteCharAt(sb.lastIndexOf(","));
	    	}
	    	sb.append(')');
	        System.out.println(sb.toString());
	    }
	    
	    //获取代理对象的所有成员方法
	    System.out.println("代理类的成员方法------------------------------");
	    Method[] methods = clazzProxy.getMethods();//获取迭代器的所有成员方法
	    for(Method method : methods){//迭代构造方法，获取每个成员方法的参数类型
	    	StringBuilder sb = new StringBuilder(method.getName());
	    	sb.append('(');
	    	Class[] clazzParams = method.getParameterTypes();
	    	if(clazzParams !=null && clazzParams.length != 0){
	    		for(Class param : clazzParams){
	    			sb.append(param.getName());
	    			sb.append(',');
	    		}
	    		sb.deleteCharAt(sb.lastIndexOf(","));
	    	}
	    	sb.append(')');
	    	System.out.println(sb.toString());
	    }
	    
	    //方法一：获取代理对象的实例
	    Constructor constructor = clazzProxy.getConstructor(InvocationHandler.class);
            //执行代理之后再返回来的的代理中会加一个带有InvocationHandler参数的构造函数，因此获取代理对象实例时要传 递一个InvocationHandler参数

	    Collection collection1 = (Collection) constructor.newInstance(new InvocationHandler(){

                                                                                       //这里使用内部类的方法传参
			@Override
			public Object invoke(Object proxy, Method method, Object[] args)
					throws Throwable {
				System.out.println("invoke.............");
				return null;
			}	    	
	    });
	    
	    //方法二：获取代理对象的实例Proxy.newProxyInstance();
	    ArrayList target = new ArrayList();//目标代理对象
            Collection retProxy = (Collection)getProxy(target,new MyAdvice());//进行代理,返回时转义必须是接口
	    retProxy.add("abc");//执行代理对象的方法，这是该方法已经被重写
	    System.out.println(retProxy.toString());//执行代理对象的方法

	}

	private static Object getProxy(final Object target,final MyAdvice advice) {
		Object proxy =  Proxy.newProxyInstance(
				target.getClass().getClassLoader(),//参数1：要代理的类的加载器，可以多个
				target.getClass().getInterfaces(),// 参数2：要代理的类所实现的接口
				new InvocationHandler() {//参数3：代理实例会调用的成员变量
					@Override
					public Object invoke(Object proxy, Method method,
							Object[] args) throws Throwable {//该方法是代理的对象中成员                                                                              //变量InvocationHandler所执行烦人方法
						//advice.beforeMethod表示在执行方法前应该做点什么
						advice.beforeMethod(method);
						Object retVal = method.invoke(target, args);//进行方法的反射，反射                                                                                             //的就是原始对象的方法
						//advice.afterMethod表示在执行方法后应该做点什么
						advice.afterMethod(method);
						return retVal;
					}
				});
		return proxy;
	}
}

二：线程

1.进程：正在进行中的程序。其实进程就是一个应用程序运行时的内存分配空间。

2.线程：其实就是进程中一个程序执行控制单元，一条执行路径。进程负责的是应用程序的空间的标示。线程负责的是应用程序的执行顺序。

一个进程至少有一个线程在运行，当一个进程中出现多个线程时，就称这个应用程序是多线程应用程序，每个线程在栈区中都有自己的执行空间，自己的方法区、自己的变量。

jvm在启动的时，首先有一个主线程，负责程序的执行，调用的是main函数。主线程执行的代码都在main方法中。

当产生垃圾时，收垃圾的动作，是不需要主线程来完成，因为这样，会出现主线程中的代码执行会停止，会去运行垃圾回收器代码，效率较低，所以由单独一个线程来负责垃圾回收。

3.随机性的原理：因为cpu的快速切换造成，哪个线程获取到了cpu的执行权，哪个线程就执行。

返回当前线程的名称：Thread.currentThread().getName()

线程的名称是由：Thread-编号定义的。编号从0开始。

线程要运行的代码都统一存放在了run方法中。

线程要运行必须要通过类中指定的方法开启。start方法。（启动后，就多了一条执行路径）

start方法：1）、启动了线程；2）、让jvm调用了run方法。

4.创建线程的第一种方式：继承Thread ，由子类复写run方法。

步骤：

4.1.定义类继承Thread类；

4.2.目的是复写run方法，将要让线程运行的代码都存储到run方法中；

4.3.通过创建Thread类的子类对象，创建线程对象；

4.4.调用线程的start方法，开启线程，并执行run方法。

5.线程状态：

被创建：start()

运行：具备执行资格，同时具备执行权；

冻结：sleep(time),wait()—notify()唤醒；线程释放了执行权，同时释放执行资格；

临时阻塞状态：线程具备cpu的执行资格，没有cpu的执行权；

消亡：stop()

6.创建线程的第二种方式：实现一个接口Runnable。

步骤：

6.1.定义类实现Runnable接口。

6.2.覆盖接口中的run方法（用于封装线程要运行的代码）。

6.3.通过Thread类创建线程对象；

6.4.将实现了Runnable接口的子类对象作为实际参数传递给Thread类中的构造函数。

为什么要传递呢？因为要让线程对象明确要运行的run方法所属的对象。

6.5.调用Thread对象的start方法。开启线程，并运行Runnable接口子类中的run方法。

7.为什么要有Runnable接口的出现？

7.1.通过继承Thread类的方式，可以完成多线程的建立。但是这种方式有一个局限性，如果一个类已经有了自己的父类，就不可以继承Thread类，因为java单继承的局限性。

可是该类中的还有部分代码需要被多个线程同时执行。这时怎么办呢？

只有对该类进行额外的功能扩展，java就提供了一个接口Runnable。这个接口中定义了run方法，其实run方法的定义就是为了存储多线程要运行的代码。

所以，通常创建线程都用第二种方式。

因为实现Runnable接口可以避免单继承的局限性。

7.2.其实是将不同类中需要被多线程执行的代码进行抽取。将多线程要运行的代码的位置单独定义到接口中。为其他类进行功能扩展提供了前提。

所以Thread类在描述线程时，内部定义的run方法，也来自于Runnable接口。

7.3.实现Runnable接口可以避免单继承的局限性。而且，继承Thread，是可以对Thread类中的方法，进行子类复写的。但是不需要做这个复写动作的话，只为定义线程代码存放位置，实现Runnable接口更方便一些。所以Runnable接口将线程要执行的任务封装成了对象。

8.多线程安全问题的原因：

通过图解：发现一个线程在执行多条语句时，并运算同一个数据时，在执行过程中，其他线程参与进来，并操作了这个数据。导致到了错误数据的产生。

9.涉及到两个因素：

9.1.多个线程在操作共享数据。

9.2.有多条语句对共享数据进行运算。

原因：这多条语句，在某一个时刻被一个线程执行时，还没有执行完，就被其他线程执行了。

10.解决安全问题的原理：

只要将操作共享数据的语句在某一时段让一个线程执行完，在执行过程中，其他线程不能进来执行就可以解决这个问题。

如何进行多句操作共享数据代码的封装呢？

java中提供了一个解决方式：就是同步代码块。

格式：

synchronized(对象) { //任意对象都可以。这个对象就是锁。

需要被同步的代码；

11.同步：

11.1.好处：解决了线程安全问题。

12.2.弊端：相对降低性能，因为判断锁需要消耗资源，产生了死锁。

12.定义同步是有前提的：

12.1.必须要有两个或者两个以上的线程，才需要同步。

12.2.多个线程必须保证使用的是同一个锁。

13.同步的第二种表现形式：

同步函数：其实就是将同步关键字定义在函数上，让函数具备了同步性。

14.同步函数是用的哪个锁呢？

通过验证，函数都有自己所属的对象this，所以同步函数所使用的锁就是this锁。

15.当同步函数被static修饰时，这时的同步用的是哪个锁呢？

静态函数在加载时所属于类，这时有可能还没有该类产生的对象，但是该类的字节码文件加载进内存就已经被封装成了对象，这个对象就是该类的字节码文件对象。

所以静态加载时，只有一个对象存在，那么静态同步函数就使用的这个对象。

这个对象就是类名.class

16.同步代码块和同步函数的区别？

同步代码块使用的锁可以是任意对象。

同步函数使用的锁是this，静态同步函数的锁是该类的字节码文件对象。

在一个类中只有一个同步，可以使用同步函数。如果有多同步，必须使用同步代码块，来确定不同的锁。所以同步代码块相对灵活一些。

17.考点问题：请写一个延迟加载的单例模式？写懒汉式；当出现多线程访问时怎么解决？加同步，解决安全问题；效率高吗？不高；怎样解决？通过双重判断的形式解决。

懒汉式：延迟加载方式。

当多线程访问懒汉式时，因为懒汉式的方法内对共性数据进行多条语句的操作。所以容易出现线程安全问题。为了解决，加入同步机制，解决安全问题。但是却带来了效率降低。

为了效率问题，通过双重判断的形式解决。

class Single{
    private static Singles = null;
    private Single(){}
    public static SinglegetInstance(){ //锁是谁？字节码文件对象；
        if(s == null){
           synchronized(Single.class){
              if(s == null)
                  s = new Single();
           }
       }
        return s;
    }
}