day04_BigData渐进学习_aclear_fire

1. JAVA多线程
2. JAVA并发包(java.util.concurrent)
3. 并发编程总结
4. JAVA JMS技术<这是一种规范.消息队列> <实现：ActiceMQ>
5. JAVA动态代理和反射

6. JVM技术——堆栈、垃圾回收

   J2EE是种规范，Tomcat是种实现。 JAVA并发编程实践-cn.pdf 深入理解Java虚拟机—JVM高级特性与最佳实践（第2版）.pdf word详情笔记请见——印象笔记-BigData-Day’s NoteBook 第**4**天 java**高级特性增强** 今天内容安排： 1、掌握多线程 2、掌握并发包下的队列 3、了解JMS 4、掌握JVM技术 5、掌握反射和动态代理

• java**多线程增强**
  • java**多线程基本知识**
    • 进程介绍

不管是我们开发的应用程序，还是我们运行的其他的应用程序，都需要先把程序安装在本地的硬盘上。然后找到这个程序的启动文件，启动程序的时候，其实是电脑把当前的这个程序加载到内存中，在内存中需要给当前的程序分配一段独立的运行空间。这片空间就专门负责当前这个程序的运行。 不同的应用程序运行的过程中都需要在内存中分配自己独立的运行空间，彼此之间不会相互的影响。我们把每个独立应用程序在内存的独立空间称为当前应用程序运行的一个进程。 进程：它是内存中的一段独立的空间，可以负责当前应用程序的运行。当前这个进程负责调度当前程序中的所有运行细节。

• 线程介绍

启动的QQ聊天软件，需要和多个人进行聊天。这时多个人之间是不能相互影响，但是它们都位于当前QQ这个软件运行时所分配的内存的独立空间中。 在一个进程中，每个独立的功能都需要独立的去运行，这时又需要把当前这个进程划分成多个运行区域，每个独立的小区域（小单元）称为一个线程。 线程：它是位于进程中，负责当前进程中的某个具备独立运行资格的空间。 进程是负责整个程序的运行，而线程是程序中具体的某个独立功能的运行。一个进程中至少应该有一个线程。

• 多线程介绍

现在的操作系统基本都是多用户，多任务的操作系统。每个任务就是一个进程。而在这个进程中就会有线程。 真正可以完成程序运行和功能的实现靠的是进程中的线程。 多线程：在一个进程中，我们同时开启多个线程，让多个线程同时去完成某些任务（功能）。 (比如后台服务系统，就可以用多个线程同时响应多个客户的请求) 多线程的目的：提高程序的运行效率。

• 多线程运行的原理

cpu在线程中做时间片的切换。 其实真正电脑中的程序的运行不是同时在运行的。CPU负责程序的运行，而CPU在运行程序的过程中某个时刻点上，它其实只能运行一个程序。而不是多个程序。而CPU它可以在多个程序之间进行高速的切换。而切换频率和速度太快，导致人的肉眼看不到。 每个程序就是进程， 而每个进程中会有多个线程，而CPU是在这些线程之间进行切换。 了解了CPU对一个任务的执行过程，我们就必须知道，多线程可以提高程序的运行效率，但不能无限制的开线程。

• 实现线程的两种方式

1、继承Thread的方式 见代码MyThreadWithExtends 2、声明实现 Runnable 接口的方式 见代码MyThreadWithImpliment

• java**同步关键词解释**
  • synchronized

加同步格式： synchronized( 需要一个任意的对象（锁） ){ <注意直接 写一个任意的对象即可.> 代码块中放操作共享数据的代码。 } 见代码MySynchronized

• synchronized的缺陷

synchronized是java中的一个关键字，也就是说是Java语言内置的特性。 如果一个代码块被synchronized修饰了，当一个线程获取了对应的锁，并执行该代码块时，其他线程便只能一直等待，等待获取锁的线程释放锁，而这里获取锁的线程释放锁只会有两种情况： 1）获取锁的线程执行完了该代码块，然后线程释放对锁的占有； 2）线程执行发生异常，此时JVM会让线程自动释放锁。 <注意 线程是让JVM管理的.> 例子1： 如果这个获取锁的线程由于要等待IO或者其他原因（比如调用sleep方法）被阻塞了，但是又没有释放锁，其他线程便只能干巴巴地等待，试想一下，这多么影响程序执行效率。 因此就需要有一种机制可以不让等待的线程一直无期限地等待下去（比如只等待一定的时间或者能够响应中断），通过Lock就可以办到。 <注意这是一个对象，就不是一个JAVA内置的 关键字特性了> 例子2： 当有多个线程读写文件时，读操作和写操作会发生冲突现象，写操作和写操作会发生冲突现象，但是读操作和读操作不会发生冲突现象。 但是采用synchronized关键字来实现同步的话，就会导致一个问题： 如果多个线程都只是进行读操作，当一个线程在进行读操作时，其他线程只能等待无法进行读操作。 因此就需要一种机制来使得多个线程都只是进行读操作时，线程之间不会发生冲突，通过Lock就可以办到。 另外，通过Lock可以知道线程有没有成功获取到锁。这个是synchronized无法办到的。 总的来说，也就是说Lock提供了比synchronized更多的功能。

2.2 lock

• lock和synchronized的区别

1）Lock不是Java语言内置的，synchronized是Java语言的关键字，因此是内置特性。Lock是一个类，通过这个类可以实现同步访问； 2）Lock和synchronized有一点非常大的不同，采用synchronized不需要用户去手动释放锁，当synchronized方法或者synchronized代码块执行完之后，系统会自动让线程释放对锁的占用；而Lock则必须要用户去手动释放锁，如果没有主动释放锁，就有可能导致出现死锁现象。

• util.concurrent.locks包下常用的类

• Lock

首先要说明的就是Lock，通过查看Lock的源码可知，Lock是一个接口：

public interface Lock { void lock(); void lockInterruptibly() throws InterruptedException; boolean tryLock(); boolean tryLock(long time, TimeUnit unit) throws InterruptedException; void unlock(); }

Lock接口中每个方法的使用： lock()、tryLock()、tryLock(long time, TimeUnit unit)、lockInterruptibly()是用来获取锁的。 unLock()方法是用来释放锁的。 四个获取锁方法的区别： lock()方法是平常使用得最多的一个方法，就是用来获取锁。如果锁已被其他线程获取，则进行等待。 由于在前面讲到如果采用Lock，必须主动去释放锁，并且在发生异常时，不会自动释放锁。因此一般来说，使用Lock必须在try{}catch{}块中进行，并且将释放锁的操作放在finally块中进行，以保证锁一定被被释放，防止死锁的发生。 tryLock()方法是有返回值的，它表示用来尝试获取锁，如果获取成功，则返回true，如果获取失败（即锁已被其他线程获取），则返回false，也就说这个方法无论如何都会立即返回。在拿不到锁时不会一直在那等待。 tryLock(long time, TimeUnit unit)方法和tryLock()方法是类似的，只不过区别在于这个方法在拿不到锁时会等待一定的时间，在时间期限之内如果还拿不到锁，就返回false。如果如果一开始拿到锁或者在等待期间内拿到了锁，则返回true。 lockInterruptibly()方法比较特殊，当通过这个方法去获取锁时，如果线程正在等待获取锁，则这个线程能够响应中断，即中断线程的等待状态。也就使说，当两个线程同时通过lock.lockInterruptibly()想获取某个锁时，假若此时线程A获取到了锁，而线程B只有等待，那么对线程B调用threadB.interrupt()方法能够中断线程B的等待过程。<等待的人可以被中断> 注意，当一个线程获取了锁之后，是不会被interrupt()方法中断的。 因此当通过lockInterruptibly()方法获取某个锁时，如果不能获取到，只有进行等待的情况下，是可以响应中断的。 而用synchronized修饰的话，当一个线程处于等待某个锁的状态，是无法被中断的，只有一直等待下去。

• ReentrantLock

直接使用lock接口的话，我们需要实现很多方法，不太方便，ReentrantLock是唯一实现了Lock接口的类，并且ReentrantLock提供了更多的方法，ReentrantLock，意思是“可重入锁”。 以下是ReentrantLock的使用案例： 例子1，lock()的正确使用方法 见代码MyLockTest 例子2，tryLock()的使用方法 见代码MyTryLock 例子3，lockInterruptibly()响应中断的使用方法： 见代码MyInterruptibly

• ReadWriteLock

ReadWriteLock也是一个接口，在它里面只定义了两个方法：

public interface ReadWriteLock { / Returns the lock used for reading. @return the lock used for reading. / Lock readLock(); / Returns the lock used for writing. @return the lock used for writing. / Lock writeLock(); }

一个用来获取读锁，一个用来获取写锁。也就是说将文件的读写操作分开，分成2个锁来分配给线程，从而使得多个线程可以同时进行读操作。下面的ReentrantReadWriteLock实现了ReadWriteLock接口。 如果拿到了writeLock的锁，其他人都不能操作了。 拿到了readLock的锁，其他人还可以进行read的操作。

• ReentrantReadWriteLock

ReentrantReadWriteLock里面提供了很多丰富的方法，不过最主要的有两个方法：readLock()和writeLock()用来获取读锁和写锁。//这个就是一点具体实现 下面通过几个例子来看一下ReentrantReadWriteLock具体用法。 例子1：假如有多个线程要同时进行读操作的话，先看一下synchronized达到的效果 见代码MySynchronizedReadWrite 例子2：改成用读写锁的话： 见代码MyReentrantReadWriteLock 注意： 不过要注意的是，如果有一个线程已经占用了读锁，则此时其他线程如果要申请写锁，则申请写锁的线程会一直等待释放读锁。 如果有一个线程已经占用了写锁，则此时其他线程如果申请写锁或者读锁，则申请的线程会一直等待释放写锁。

• Lock和synchronized的选择

  1）Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现； 2）synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动通过unLock()去释放锁，则很可能造成死锁现象，因此使用Lock时需要在finally块中释放锁； 3）Lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够响应中断； 4）通过Lock可以知道有没有成功获取锁，而synchronized却无法办到。 5）Lock可以提高多个线程进行读操作的效率。 在性能上来说，如果竞争资源不激烈，两者的性能是差不多的，而当竞争资源非常激烈时（即有大量线程同时竞争），此时Lock的性能要远远优于synchronized。所以说，在具体使用时要根据适当情况选择。 平常使用不能无限制的 添加线程——一上来就new 一个Thread() 只是runnable对象不一样。直接从线程池中找线程 添加上去Runnable即可。

• java**并发包**

  • java**并发包介绍**

JDK5.0 以后的版本都引入了高级并发特性，大多数的特性在java.util.concurrent 包中，是专门用于多线程发编程的，充分利用了现代多处理器和多核心系统的功能以编写大规模并发应用程序。主要包含原子量**<不优化，每次都拿真实地方>**、并发集合、同步器、可重入锁，并对线程池的构造提供 保证构造的线程是同一个视图。 了强力的支持。 线程池

• 线程池的5中创建方式：

• Single Thread Executor : 只有一个线程的线程池，因此所有提交的任务是顺序执行，

代码： Executors.newSingleThreadExecutor()

• Cached Thread Pool : 线程池里有很多线程需要同时执行，老的可用线程将被新的任务触发重新执行，如果线程超过60秒内没执行，那么将被终止并从池中删除，

代码：Executors.newCachedThreadPool() //有一定的回收60s 会和搜房党阀。

• Fixed Thread Pool : 拥有固定线程数的线程池，如果没有任务执行，那么线程会一直等待，

代码： Executors.newFixedThreadPool(4) 在构造函数中的参数4是线程池的大小，你可以随意设置，也可以和cpu的核数量保持一致，获取cpu的核数量int cpuNums = Runtime.getRuntime().availableProcessors();

• Scheduled Thread Pool : 用来调度即将执行的任务的线程池，可能是 不是直接执行, 每隔多久执行一次… 策略型的

代码：Executors.newScheduledThreadPool()

• Single Thread Scheduled Pool : 只有一个线程，用来调度任务在指定时间执行，代码：newSingleThreadScheduledExecutor()

• 线程池的使用

  提交 Runnable ，任务完成后 Future 对象返回 null 调用excute,提交任务, 匿名Runable重写run方法, run方法里是业务逻辑 见代码：ThreadPoolWithRunable 提交 Callable，该方法返回一个 Future 实例表示任务的状态 调用submit提交任务, 匿名Callable,重写call方法, 有返回值, 获取返回值会阻塞,一直要等到线程任务返回结果 见代码：ThreadPoolWithcallable

/** * callable 跟runnable的区别： runnable的run方法不会有任何返回结果，所以主线程无法获得任务线程的返回值 callable的call方法可以返回结果，但是主线程在获取时是被阻塞，需要等待任务线程返回才能拿到结果 @author acanprince / public class ThreadPoolWithcallable { public static void main(String[] args) throws InterruptedException, ExecutionException { ExecutorService pool = Executors.newFixedThreadPool(4); for(int i = 0; i < 10; i++){ Future submit = pool.submit(new Callable(){ @Override public String call() throws Exception { //System.out.println(“a”); Thread.sleep(5000); return “b—“+Thread.currentThread().getName(); } }); //从Future中get结果，这个方法是会被阻塞的，一直要等到线程任务返回结果 注意所以也会有一定的危险！反回不回来就 卡死！ System.out.println(submit.get()); } pool.shutdown(); } } 学习电商的 服务器并发性 就是需要进行以上的学习 理解！！！综合所学的这些部分！

• java**并发包消息队列及在开源软件中的应用**

BlockingQueue也是java.util.concurrent下的主要用来控制线程同步的工具。 主要的方法是：put、take一对阻塞存取；add、poll一对非阻塞存取。 插入: 1)add(anObject):把anObject加到BlockingQueue里,即如果BlockingQueue可以容纳,则返回true,否则抛出异常,不好 2)offer(anObject):表示如果可能的话,将anObject加到BlockingQueue里,即如果BlockingQueue可以容纳,则返回true,否则返回false. 3)put(anObject):把anObject加到BlockingQueue里,如果BlockQueue没有空间,则调用此方法的线程被阻断直到BlockingQueue里面有空间再继续, 有阻塞, 放不进去就等待 读取： 4)poll(time):取走BlockingQueue里排在首位的对象,若不能立即取出,则可以等time参数规定的时间,取不到时返回null; 取不到返回null 5)take():取走BlockingQueue里排在首位的对象,若BlockingQueue为空,阻断进入等待状态直到Blocking有新的对象被加入为止; 阻塞, 取不到就一直等 其他 int remainingCapacity();返回队列剩余的容量，在队列插入和获取的时候，不要瞎搞，数 据可能不准, 不能保证数据的准确性 boolean remove(Object o); 从队列移除元素，如果存在，即移除一个或者更多，队列改 变了返回true public boolean contains(Object o); 查看队列是否存在这个元素，存在返回true int drainTo(Collection<? super E> c); //移除此队列中所有可用的元素,并将它们添加到给定 collection 中。取出放到集合中 int drainTo(Collection<? super E> c, int maxElements); 和上面方法的区别在于，指定了移 动的数量; 取出指定个数放到集合 BlockingQueue有四个具体的实现类,常用的两种实现类为： 1、ArrayBlockingQueue：一个由数组支持的有界阻塞队列，规定大小的BlockingQueue,其构造函数必须带一个int参数来指明其大小.其所含的对象是以FIFO(先入先出)顺序排序的。 2、LinkedBlockingQueue：大小不定的BlockingQueue,若其构造函数带一个规定大小的参数,生成的BlockingQueue有大小限制,若不带大小参数,所生成的BlockingQueue的大小由Integer.MAX_VALUE来决定.其所含的对象是以FIFO(先入先出)顺序排序的。 LinkedBlockingQueue 可以指定容量，也可以不指定，不指定的话，默认最大是Integer.MAX_VALUE,其中主要用到put和take方法，put方法在队列满的时候会阻塞直到有队列成员被消费，take方法在队列空的时候会阻塞，直到有队列成员被放进来。 //即上面的也是有空间大小的。只是空间比较大 LinkedBlockingQueue和ArrayBlockingQueue区别： LinkedBlockingQueue和ArrayBlockingQueue比较起来,它们背后所用的数据结构不一样,导致LinkedBlockingQueue的数据吞吐量要大于ArrayBlockingQueue,但在线程数量很大时其性能的可预见性低于ArrayBlockingQueue. 当我们用流式的 storm框架的时候——会用到很多BlockingQueue！ 生产者消费者的示例代码： 见代码

• java**并发编程的一些总结**
  • 不应用线程池的缺点

有些开发者图省事，遇到需要多线程处理的地方，直接new Thread(…).start()，对于一般场景是没问题的，但如果是在并发请求很高的情况下，就会有些隐患：

• 新建线程的开销。线程虽然比进程要轻量许多，但对于JVM来说，新建一个线程的代价还是挺大的，决不同于新建一个对象
• 资源消耗量。没有一个池来限制线程的数量，会导致线程的数量直接取决于应用的并发量，这样有潜在的线程数据巨大的可能，那么资源消耗量将是巨大的

• 稳定性。当线程数量超过系统资源所能承受的程度，稳定性就会成问题

• 制定执行策略

在每个需要多线程处理的地方，不管并发量有多大，需要考虑线程的执行策略

• 任务以什么顺序执行
• 可以有多少个任务并发执行
• 可以有多少个任务进入等待执行队列
• 系统过载的时候，应该放弃哪些任务？如何通知到应用程序？

• 一个任务的执行前后应该做什么处理

• 线程池的类型

不管是通过Executors创建线程池，还是通过Spring来管理，都得清楚知道有哪几种线程池：

• FixedThreadPool：定长线程池，提交任务时创建线程，直到池的最大容量，如果有线程非预期结束，会补充新线程
• CachedThreadPool：可变线程池，它犹如一个弹簧，如果没有任务需求时，它回收空闲线程，如果需求增加，则按需增加线程，不对池的大小做限制
• SingleThreadExecutor：单线程。处理不过来的任务会进入FIFO队列等待执行
• SecheduledThreadPool：周期性线程池。支持执行周期性线程任务

其实，这些不同类型的线程池都是通过构建一个ThreadPoolExecutor来完成的，所不同的是corePoolSize,maximumPoolSize,keepAliveTime,unit,workQueue,threadFactory这么几个参数。具体可以参见JDK DOC。

• 线程池饱和策略

由以上线程池类型可知，除了CachedThreadPool其他线程池都有饱和的可能，当饱和以后就需要相应的策略处理请求线程的任务，比如，达到上限时通过ThreadPoolExecutor.setRejectedExecutionHandler方法设置一个拒绝任务的策略，JDK提供了AbortPolicy、CallerRunsPolicy、DiscardPolicy、DiscardOldestPolicy几种策略，具体差异可见JDK DOC

• 线程无依赖性

多线程任务设计上尽量使得各任务是独立无依赖的，所谓依赖性可两个方面：

• 线程之间的依赖性。如果线程有依赖可能会造成死锁或饥饿
• 调用者与线程的依赖性。调用者得监视线程的完成情况，影响可并发量

当然，在有些业务里确实需要一定的依赖性，比如调用者需要得到线程完成后结果，传统的Thread是不便完成的，因为run方法无返回值，只能通过一些共享的变量来传递结果，但在Executor框架里可以通过Future和Callable实现需要有返回值的任务，当然线程的异步性导致需要有相应机制来保证调用者能等待任务完成，关于Future和Callable的用法前文已讲解；

• java JMS**技术**
  • 什么是**JMS**

JMS即Java消息服务（Java Message Service）应用程序接口是一个Java平台中关于面向消息中间件（MOM）的API，用于在两个应用程序之间，或分布式系统中发送消息，进行异步通信。Java消息服务是一个与具体平台无关的API，绝大多数MOM提供商都对JMS提供支持。 JMS是一种与厂商无关的 API，用来访问消息收发系统消息。它类似于JDBC(Java Database Connectivity)：这里，JDBC 是可以用来访问许多不同关系数据库的 API，而 JMS 则提供同样与厂商无关的访问方法，以访问消息收发服务。许多厂商都支持 JMS，包括 IBM 的 MQSeries、BEA的 Weblogic JMS service和 Progress 的 SonicMQ，这只是几个例子。 JMS 使您能够通过消息收发服务（有时称为消息中介程序或路由器）从一个 JMS 客户机向另一个 JMS客户机发送消息。消息是 JMS 中的一种类型对象，由两部分组成：报头和消息主体。报头由路由信息以及有关该消息的元数据组成。消息主体则携带着应用程序的数据或有效负载。根据有效负载的类型来划分，可以将消息分为几种类型，它们分别携带：简单文本(TextMessage)、可序列化的对象 (ObjectMessage)、属性集合 (MapMessage)、字节流 (BytesMessage)、原始值流 (StreamMessage)，还有无有效负载的消息 (Message)。

• JMS**规范**
  • 专业技术规范

JMS（Java Messaging Service）是Java平台上有关面向消息中间件(MOM)的技术规范，它便于消息系统中的Java应用程序进行消息交换,并且通过提供标准的产生、发送、接收消息的接口简化企业应用的开发，翻译为Java消息服务。

• 体系架构

JMS由以下元素组成。 JMS提供者provider：连接面向消息中间件的，JMS接口的一个实现。提供者可以是Java平台的JMS实现，也可以是非Java平台的面向消息中间件的适配器。 JMS客户：生产或消费基于消息的Java的应用程序或对象。 JMS生产者：创建并发送消息的JMS客户。 JMS消费者：接收消息的JMS客户。 JMS消息：包括可以在JMS客户之间传递的数据的对象 JMS队列：一个容纳那些被发送的等待阅读的消息的区域。与队列名字所暗示的意思不同，消息的接受顺序并不一定要与消息的发送顺序相同。一旦一个消息被阅读，该消息将被从队列中移走。 JMS主题：一种支持发送消息给多个订阅者的机制。

• Java**消息服务应用程序结构支持两种模型**

• 点对点或队列模型

在点对点或队列模型下，一个生产者向一个特定的队列发布消息，一个消费者从该队列中读取消息。这里，生产者知道消费者的队列，并直接将消息发送到消费者的队列。 这种模式被概括为： 只有一个消费者将获得消息 生产者不需要在接收者消费该消息期间处于运行状态，接收者也同样不需要在消息发送时处于运行状态。 每一个成功处理的消息都由接收者签收 2、发布者/订阅者模型 发布者/订阅者模型支持向一个特定的消息主题发布消息。0或多个订阅者可能对接收来自特定消息主题的消息感兴趣。在这种模型下，发布者和订阅者彼此不知道对方。这种模式好比是匿名公告板。 这种模式被概括为： 多个消费者可以获得消息 在发布者和订阅者之间存在时间依赖性。发布者需要建立一个订阅（subscription），以便客户能够订阅。订阅者必须保持持续的活动状态以接收消息，除非订阅者建立了持久的订阅。在那种情况下，在订阅者未连接时发布的消息将在订阅者重新连接时重新发布。 ActiveMQ 应付下J2EE还是可以的。但是 如果我们需要 进行大数据开发，需要进行卡发卡使用。

• 代码演示

1.下载ActiveMQ 去官方网站下载：http://activemq.apache.org/ 2.运行ActiveMQ 解压缩apache-activemq-5.5.1-bin.zip， 修改配置文件activeMQ.xml，将0.0.0.0修改为localhost

//注释 当前配置是，当前支持的通用协议的配置

然后双击apache-activemq-5.5.1\\bin\\activemq.bat运行ActiveMQ程序。 启动ActiveMQ以后，登陆：http://localhost:8161/admin/，创建一个Queue，命名为FirstQueue。 3.运行代码

• 常用的**JMS**实现

要使用Java消息服务，你必须要有一个JMS提供者，管理会话和队列。既有开源的提供者也有专有的提供者。 开源的提供者包括： Apache ActiveMQ JBoss 社区所研发的 HornetQ Joram Coridan的MantaRay The OpenJMS Group的OpenJMS 专有的提供者包括： BEA的BEA WebLogic Server JMS TIBCO Software的EMS GigaSpaces Technologies的GigaSpaces Softwired 2006的iBus IONA Technologies的IONA JMS SeeBeyond的IQManager（2005年8月被Sun Microsystems并购） webMethods的JMS+ - my-channels的Nirvana Sonic Software的SonicMQ SwiftMQ的SwiftMQ IBM的WebSphere MQ 生产者生产者把消息放到 消息池盒子当中<一堆大数据出来的需要分析的数据>，然后经由kafak消息中间件 进行消息存储： 消费者通过 提取kafak中的信息进行 处理<1. 方便提取

1. 方便 后者转赶上前者， 进行速度的缓冲，
2. 也方便进行统一管理与 处理。 其它池子好进行提取。>

• java**动态代理、反射**
  • 反射

通过反射的方式可以获取class对象中的属性、方法、构造函数等，一下是实例： 类似于 通过对应包或类的字符串进行 响应对象中的class对象的提取。

package cn.itcast_04_reflect; import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.Method; import java.util.ArrayList; import java.util.List; import org.junit.Before; import org.junit.Test; public class MyReflect { public String className = null; @SuppressWarnings(“rawtypes”) public Class personClass = null; /** * 反射Person类 @throws Exception / @Before public void init() throws Exception { className = “cn.itcast_04_reflect.Person”; personClass = Class._forName_(className); } / 获取某个class文件对象 通过 class类名获取对应的 class文件对象. */ @Test public void getClassName() throws Exception { System._out_.println(personClass); } / 获取某个class文件对象的另一种方式 直接获取 package 当中已经有的，文件对象. / @Test public void getClassName2() throws Exception { System._out_.println(Person.class); } /** 创建一个class文件表示的实例对象，底层会调用空参数的构造方法 / @Test public void getNewInstance() throws Exception { System._out_.println(personClass.newInstance()); } / 获取非私有的构造函数 获取唯一的 构造函数,进行唯一的方法调用.也可以获得实例. */ @SuppressWarnings({ “rawtypes”, “unchecked” }) @Test public void getPublicConstructor() throws Exception { Constructor constructor = personClass.getConstructor(Long.class,String.class); Person person = (Person)constructor.newInstance(100L,”zhangsan”); System._out_.println(person.getId()); System._out_.println(person.getName()); } / 获得私有的构造函数 / @SuppressWarnings({ “rawtypes”, “unchecked” }) @Test public void getPrivateConstructor() throws Exception { Constructor con = personClass.getDeclaredConstructor(String.class); //暴力获取 私有权限的 链接。 con.setAccessible(true);//强制取消Java的权限检测 Person person2 = (Person)con.newInstance(“zhangsan”); System._out_.println(““+person2.getName()); } / 访问非私有的成员变量 / @SuppressWarnings({ “rawtypes”, “unchecked” }) @Test public void getNotPrivateField() throws Exception { Constructor constructor = personClass.getConstructor(Long.class,String.class); Object obj = constructor.newInstance(100L,”zhangsan”); Field field = personClass.getField(“name”); field.set(obj, “lisi”); System._out_.println(field.get(obj)); } / 访问私有的成员变量 / @SuppressWarnings({ “rawtypes”, “unchecked” }) @Test public void getPrivateField() throws Exception { // Constructor constructor2 = personClass.getConstructor(Long,class); // Object newInstance = constructor2.newInstance(100L); // // // personClass.getDeclaredFields(“name”); Constructor constructor = personClass.getConstructor(Long.class); Object obj = constructor.newInstance(100L); Field field2 = personClass.getDeclaredField(“id”); field2.setAccessible(true);//强制取消Java的权限检测 field2.set(obj,10000L); System._out_.println(field2.get(obj)); } / 获取非私有的成员函数 / @SuppressWarnings({ “unchecked” }) @Test public void getNotPrivateMethod() throws Exception { System._out_.println(personClass.getMethod(“toString”)); Object obj = personClass.newInstance();//获取空参的构造函数 Method toStringMethod = personClass.getMethod(“toString”); //指定代理对象 执行对应的方法. 当我们发过来的都是字符串 并不知道我们应该执行的方法是什么，只能通过·发送给我们的字符串货值用的什么具体方法. Object object = toStringMethod.invoke(obj); System._out_.println(object); } / 获取私有的成员函数 / @SuppressWarnings(“unchecked”) @Test public void getPrivateMethod() throws Exception { Object obj = personClass.newInstance();//获取空参的构造函数 Method method = personClass.getDeclaredMethod(“getSomeThing”); method.setAccessible(true); Object value = method.invoke(obj); System._out_.println(value); } / / @Test public void otherMethod() throws Exception { //当前加载这个class文件的那个类加载器对象 System._out_.println(personClass.getClassLoader()); //获取某个类实现的所有接口 Class[] interfaces = personClass.getInterfaces(); for (Class class1 : interfaces) { System._out_.println(class1); } //反射当前这个类的直接父类 extends没有.就是Object的孩子 System._out_.println(personClass.getGenericSuperclass()); / getResourceAsStream这个方法可以获取到一个输入流，这个输入流会关联到name所表示的那个文件上。 / //path 不以’/‘开头时默认是从此类所在的包下取资源<更小>，以’/‘开头则是从ClassPath根下获取。其只是通过path构造一个绝对路径，最终还是由ClassLoader获取资源。 System._out_.println(personClass.getResourceAsStream(“/log4j.properties”)); System._out_.println(personClass.getResourceAsStream(“log4j.properties”)); //判断当前的Class对象表示是否是数组 System._out_.println(personClass.isArray()); System._out_.println(new String[3].getClass().isArray()); //判断当前的Class对象表示是否是枚举类 System._out_.println(personClass.isEnum()); System._out_.println(Class._forName_(“cn.itcast_04_reflect.City”).isEnum()); //判断当前的Class对象表示是否是接口 System._out_.println(personClass.isInterface()); System._out_**.println(Class._forName_(“cn.itcast_04_reflect.TestInterface”).isInterface()); } }

• 动态代理

在之前的代码调用阶段，我们用action调用service的方法实现业务即可。 由于之前在service中实现的业务可能不能够满足当先客户的要求，需要我们重新修改service中的方法，但是service的方法不只在我们这个模块使用，在其他模块也在调用，其他模块调用的时候，现有的service方法已经能够满足业务需求，所以我们不能只为了我们的业务而修改service，导致其他模块授影响。 那怎么办呢？ 可以通过动态代理的方式，扩展我们的service中的方法实现，使得在原有的方法中增加更多的业务，而不是实际修改service中的方法，这种实现技术就叫做动态代理。 动态代理：在不修改原业务的基础上，基于原业务方法，进行重新的扩展，实现新的业务。 例如下面的例子：

• 旧业务

买家调用action，购买衣服，衣服在数据库的标价为50元，购买流程就是简单的调用。

• 新业务

在原先的价格上可以使用优惠券，但是这个功能在以前没有实现过，我们通过代理类，代理了原先的接口方法，在这个方法的基础上，修改了返回值。 代理实现流程：

• 书写代理类和代理方法，在代理方法中实现代理newProxyInstance
• 代理中需要的参数分别为：被代理的类的类加载器getClassLoader()，被代理类的所有实现接口new Class[] { Interface.class }，句柄方法new InvocationHandler()
• 在句柄方法中复写invoke<调用>方法，invoke方法的输入有3个参数Object proxy（代理类对象）, Method method（被代理类的方法）,Object[] args（被代理类方法的传入参数），在这个方法中，我们可以定制化的开发新的业务。
• 获取代理类，强转成被代理的接口
• 最后，我们可以像没被代理一样，调用接口的认可方法，方法被调用后，方法名和参数列表将被传入代理类的invoke方法中，进行新业务的逻辑流程。

原业务接口IBoss

public interface IBoss {//接口 int yifu(String size); }

原业务实现类

public class Boss implements IBoss{ public int yifu(String size){ System.err.println(“天猫小强旗舰店，老板给客户发快递——衣服型号：”+size); //这件衣服的价钱，从数据库读取 return 50; } public void kuzi(){ System.err.println(“天猫小强旗舰店，老板给客户发快递——裤子”); } }

原业务调用

public class SaleAction { @Test public void saleByBossSelf() throws Exception { IBoss boss = new Boss(); System.out.println(“老板自营！”); int money = boss.yifu(“xxl”); System.out.println(“衣服成交价：” + money); } }

代理类

public static IBoss getProxyBoss(final int discountCoupon) throws Exception { Object proxedObj = Proxy.newProxyInstance(Boss.class.getClassLoader(), new Class[] { IBoss.class }, new InvocationHandler() { public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { Integer returnValue = (Integer) method.invoke(new Boss(), args);// 调用原始对象以后返回的值 return returnValue - discountCoupon; } }); return (IBoss)proxedObj; } }

新业务调用

public class ProxySaleAction { @Test public void saleByProxy() throws Exception { IBoss boss = ProxyBoss.getProxyBoss(20);// 将代理的方法实例化成接口 System.out.println(“代理经营！”); int money = boss.yifu(“xxl”);// 调用接口的方法，实际上调用方式没有变 System.out.println(“衣服成交价：” + money); } }

动态代理的模板：

• Socket**编程模板：**

——利用socket来进行远程远程过程调用 服务器<类方法 最好用反射方法，这样灵活——根据发过来的类来进行 灵活的调用请求。> WebService 封装http协议等等. 服务器利用代码 托管封装到—Tomcat容器当中。然后 Tomcat封装的http协议action然后 client就可以通过http直接调用服务器了。 <以上方法 太冗余。所以我们进行了 简化的socket通信>

ServiceServer <服务器端>

package cn.itcast.bigdata.socket; import java.io.IOException; import java.net.InetSocketAddress; import java.net.ServerSocket; import java.net.Socket; public class ServiceServer { public static void main(String[] args) { ServerSocket server; try { //创建 一个serversocket 绑定到本机的 8899 端口上. server = new ServerSocket(); server.bind(new InetSocketAddress(“localhost”, 8899)); //监听并接受客户端的李连杰请求，accept是祖册方法 会一直等待。客户端有请求连接才返回 // 创建一个serversocket，绑定到本机的8899端口上 // 接受客户端的连接请求;accept是一个阻塞方法，会一直等待，到有客户端请求连接才返回 while (true) { Socket socket = server.accept(); //业务逻辑 抛出业务类进行处理. new Thread(new ServiceServerTask(socket)).start(); } } catch (IOException e1) { // TODO 自动生成的 catch 块 e1.printStackTrace(); } } }

ServiceServerTask<服务器端 线程 socket实现类>

package cn.itcast.bigdata.socket; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.io.OutputStream; import java.io.PrintWriter; import java.lang.reflect.Parameter; import java.net.Socket; public class ServiceServerTask implements Runnable{ Socket socket; InputStream in; OutputStream out; public ServiceServerTask(Socket socket) { // TODO 自动生成的构造函数存根 this.socket = socket; } @Override public void run() { // TODO 自动生成的方法存根 //从socket 连接中获取到与client之间的网络罗通信输入流 try { in = socket.getInputStream(); out = socket.getOutputStream(); BufferedReader br = new BufferedReader(new InputStreamReader(in)); //用 此方法读取一行 客户端传输过来的数据 // String line = “”; // String param = “”; // while( (line = br.readLine())!=null ) { // param += line; // } // 多行就用上方的方法。 //从网络通信输入流中读取客户端发送过来的数据 //注意：socketinputstream的读数据的方法都是阻塞的 String param = br.readLine(); System.out.println(Thread.currentThread().getName()+”线程在服务器中，获取到参数为:” + param); /* 作业： 将以下业务调用逻辑写成更加通用的：可以根据客户端发过来的调用类名、调用方法名、调用该参数来灵活调用 《反射》 即进行动态代理！！！！！！ 未完成！！！ */ GetDataServiceImpl getDataServiceImpl = new GetDataServiceImpl(); String result = getDataServiceImpl.getData(param); //将调用结果写到sokect的输出流中，以发送给客户端 注意服务器。先收到 客户端发来的，然后自己再发出带回车符的 PW！！！ //注意28行—输出也是输出到 socket通信到中去！！ PrintWriter pw = new PrintWriter(out); pw.println(result); pw.flush(); } catch (IOException e) { e.printStackTrace(); }finally{ try { in.close(); out.close(); socket.close(); } catch (IOException e) { e.printStackTrace(); } } } }

ServiceClient<客户端>

package cn.itcast.bigdata.socket; import java.io.BufferedReader; import java.io.InputStream; import java.io.InputStreamReader; import java.io.OutputStream; import java.io.PrintWriter; import java.net.Socket; public class ServiceClient { public static void main(String[] args) throws Exception { /*ServiceIterface service = ProxyUtils.getProxy(ServiceIterface.class,”methodA”,hostname,port); Result = service.methodA(parameters);*/ // 向服务器发出请求建立连接 Socket socket = new Socket(“localhost”, 8899); // 从socket中获取输入输出流 InputStream inputStream = socket.getInputStream(); OutputStream outputStream = socket.getOutputStream(); PrintWriter pw = new PrintWriter(outputStream); pw.println(“hello”); pw.flush(); BufferedReader br = new BufferedReader(new InputStreamReader(inputStream)); String result = br.readLine(); System.out.println(result); inputStream.close(); outputStream.close(); socket.close(); } }

GetDataServiceImpl

/** * <实现方法,最好在 ServiceServerTask当中进行 反射的通用书写方法.> * */ package cn.itcast.bigdata.socket; public class GetDataServiceImpl { public String getData(String param){ return “ok-“+param; } }

• java JVM**技术**
  • java**监控工具使用**
    • jconsole

jconsole是一种集成了上面所有命令功能的可视化工具，可以分析jvm的内存使用情况和线程等信息。 启动**jconsole 通过JDK/bin目录下的“jconsole.exe”启动Jconsole后，将自动搜索出本机运行的所有JVM进程，不需要用户使用jps来查询了，双击其中一个进程即可开始监控。也可以“远程连接服务器，进行远程虚拟机的监控。” 概览页面** 概述页面显示的是整个虚拟机主要运行数据的概览。

• jvisualvm

提供了和jconsole的功能类似，提供了一大堆的插件。 插件中，Visual GC（可视化GC）还是比较好用的，可视化GC可以看到内存的具体使用情况。

• java**内存模型**
  • 内存模型图解

Java虚拟机在执行Java程序的过程中，会把它所管理的内存划分为若干个不同的数据区。这些区域有各自的用途，以及创建和销毁的时间，有的区域随着虚拟机进程的启动而存在，有的区域则依赖用户线程的启动和结束而建立和销毁，我们可以将这些区域统称为Java运行时数据区域。 如下图是一个内存模型的关系图（详情见图：内存划分.png）： 如上图所示，Java虚拟机运行时数据区域被分为五个区域：堆(Heap)、栈(Stack)、本地方法栈(Native Stack)、方法区(Method Area)、程序计数器(Program Count Register)。

• 堆（**Heap**）

对于大多数应用来说，Java Heap是Java虚拟机管理的内存的最大一块，这块区域随着虚拟机的启动而创建。在实际的运用中，我们创建的对象和数组就是存放在堆里面。如果你听说线程安全的问题，就会很明确的知道Java Heap是一块共享的区域，操作共享区域的成员就有了锁和同步。 与Java Heap相关的还有Java的垃圾回收机制（GC）,Java Heap是垃圾回收器管理的主要区域。程序猿所熟悉的新生代、老生代、永久代的概念就是在堆里面，现在大多数的GC基本都采用了分代收集算法。如果再细致一点，Java Heap还有Eden空间，From Survivor空间,To Survivor空间等。 Java Heap可以处于物理上不连续的内存空间中，只要逻辑上是连续的即可。

• 栈（**Stack**）

相对于Java Heap来讲，Java Stack是线程私有的，她的生命周期与线程相同。Java Stack描述的是Java方法执行时的内存模型，每个方法执行时都会创建一个栈帧（Stack Frame）用语存储局部变量表、操作数栈、动态链接、方法出口等信息。从下图从可以看到，每个线程在执行一个方法时，都意味着有一个栈帧在当前线程对应的栈帧中入栈和出栈。 图中可以看到每一个栈帧中都有局部变量表。局部变量表存放了编译期间的各种基本数据类型，对象引用等信息。

• 本地方法栈（**Native Stack**）

本地方法栈（Native Stack）与Java虚拟机站（Java Stack）所发挥的作用非常相似，他们之间的区别在于虚拟机栈为虚拟机栈执行java方法（也就是字节码）服务，而本地方法栈则为使用到Native方法服务。

• 方法区（**Method Area**）

方法区（Method Area）与堆（Java Heap）一样，是各个线程共享的内存区域，它用于存储虚拟机加载的类信息，常量，静态变量，即时编译器编译后的代码等数据。虽然Java虚拟机规范把方法区描述为堆的一个逻辑部分，但是她却有一个别名叫做非堆（Non-Heap）。分析下Java虚拟机规范，之所以把方法区描述为堆的一个逻辑部分，应该觉得她们都是存储数据的角度出发的。一个存储对象数据（堆），一个存储静态信息(方法区)。 在上文中，我们看到堆中有新生代、老生代、永久代的描述。为什么我们将新生代、老生代、永久代三个概念一起说，那是因为HotSpot虚拟机的设计团队选择把GC分代收集扩展至方法区，或者说使用永久代来实现方法区而已。这样HotSpot的垃圾收集器就能想管理Java堆一样管理这部分内存。简单点说就是HotSpot虚拟机中内存模型的分代，其中新生代和老生代在堆中，永久代使用方法区实现。根据官方发布的路线图信息，现在也有放弃永久代并逐步采用Native Memory来实现方法区的规划，在JDK1.7的HotSpot中，已经把原本放在永久代的字符串常量池移出。

• 总结

• 线程私有的数据区域有：

Java虚拟机栈（Java Stack） 本地方法栈（Native Stack）

• 线程共有的数据区域有：

堆（Java Heap） 方法区

• JVM**参数列表**

java -Xmx3550m -Xms3550m -Xmn2g -Xss128k -XX:NewRatio=4 -XX:SurvivorRatio=4 -XX:MaxPermSize=16m -XX:MaxTenuringThreshold=0 -Xmx3550m：最大堆内存为3550M。 -Xms3550m：初始堆内存为3550m。 此值可以设置与-Xmx相同，以避免每次垃圾回收完成后JVM重新分配内存。 -Xmn2g：设置年轻代大小为2G。 整个堆大小=年轻代大小 + 年老代大小 + 持久代大小。持久代一般固定大小为64m，所以增大年轻代后，将会减小年老代大小。此值对系统性能影响较大，Sun官方推荐配置为整个堆的3/8。 -Xss128k：设置每个线程的堆栈大小。 JDK5.0以后每个线程堆栈大小为1M，在相同物理内存下，减小这个值能生成更多的线程。但是操作系统对一个进程内的线程数还是有限制的，不能无限生成，经验值在 3000~5000左右。 -XX:NewRatio=4:设置年轻代（包括Eden和两个Survivor区）与年老代的比值（除去持久代）。设置为4，则年轻代与年老代所占比值为1：4，年轻代占整个堆栈的1/5 -XX:SurvivorRatio=4：设置年轻代中Eden区与Survivor区的大小比值。 设置为4，则两个Survivor区与一个Eden区的比值为2:4，一个Survivor区占整个年轻代的1/6 -XX:MaxPermSize=16m:设置持久代大小为16m。 -XX:MaxTenuringThreshold=0：设置垃圾最大年龄。 如果设置为0的话，则年轻代对象不经过Survivor区，直 接进入年老代。对于年老代比较多的应用，可以提高效率。如果将此值设置为一个较大值，则年轻代对象会在Survivor区进行多次复制，这样可以增加对象 再年轻代的存活时间，增加在年轻代即被回收的概论。 收集器设置 -XX:+UseSerialGC:设置串行收集器 -XX:+UseParallelGC:设置并行收集器 -XX:+UseParalledlOldGC:设置并行年老代收集器 -XX:+UseConcMarkSweepGC:设置并发收集器 垃圾回收统计信息 -XX:+PrintGC -XX:+PrintGCDetails -XX:+PrintGCTimeStamps -Xloggc:filename 并行收集器设置 -XX:ParallelGCThreads=n:设置并行收集器收集时使用的CPU数。并行收集线程数。 -XX:MaxGCPauseMillis=n:设置并行收集最大暂停时间 -XX:GCTimeRatio=n:设置垃圾回收时间占程序运行时间的百分比。公式为1/(1+n) 并发收集器设置 -XX:+CMSIncrementalMode:设置为增量模式。适用于单CPU情况。 -XX:ParallelGCThreads=n:设置并发收集器年轻代收集方式为并行收集时，使用的CPU数。并行收集线程数。

• jvm**案例演示**

内存： Jconsole的内存标签相当于可视化的jstat命令，用于监视收集器管理的虚拟机内存（java堆和永久代）的变化趋势。 我们通过下面的一段代码体验一下它的监视功能。运行时设置的虚拟机参数为：-Xms100m -Xmx100m -XX:+UseSerialGC，这段代码的作用是以64kb/50毫秒的速度往java堆内存中填充数据。

public class TestMemory { static class OOMObject { public byte[] placeholder = new byte[64 * 1024]; } public static void fillHeap(int num) throws Exception { ArrayList list = new ArrayList(); for (int i = 0; i < num; i++) { Thread.sleep(50); list.add(new OOMObject()); } System.gc(); } public static void main(String[] args) throws Exception { fillHeap(1000); Thread.sleep(500000); } }

从图中可以看出，运行轨迹成曲线增长，循环1000次后，虽然整个新生代Eden和Survivor区都基本上被清空了，但是老年代仍然保持峰值状态，这说明，填充的数据在GC后仍然存活，因为list的作用域没有结束。如果把System.gc();移到fillHeap(1000);后，就可以全部回收掉。 线程： jconsole线程标签相当于可视化了jstack命令，遇到线程停顿时，可以使用这个也签进行监控分析。线程长时间停顿的主要原因有：等待外部资源（数据库连接等），死循环、锁等待。下面的代码将演示这几种情况：

package cn.java.jvm; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; public class TestThread { / 死循环演示 @param args / public static void createBusyThread() { Thread thread = new Thread(new Runnable() { @Override public void run() { System.out.println(“createBusyThread”); while (true) ; } }, “testBusyThread”); thread.start(); } / 线程锁等待 @param args / public static void createLockThread(final Object lock) { Thread thread = new Thread(new Runnable() { @Override public void run() { System.out.println(“createLockThread”); synchronized (lock) { try { lock.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } } }, “testLockThread”); thread.start(); } public static void main(String[] args) throws Exception { BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); br.readLine(); createBusyThread(); br.readLine(); Object object = new Object(); createLockThread(object); } }

main线程：追踪到需要键盘录入 testBusyThread线程：线程阻塞在18行的while（true），直到线程切换，很耗性能 testLockThread线程：出于waitting状态，等待notify 死锁：

package cn.java.jvm; public class TestDeadThread implements Runnable { int a, b; public TestDeadThread(int a, int b) { this.a = a; this.b = b; } @Override public void run() { System.out.println(“createDeadThread”); synchronized (Integer.valueOf(a)) { synchronized (Integer.valueOf(b)) { System.out.println(a + b); } } } public static void main(String[] args) { for (int i = 0; i < 100; i++) { new Thread(new TestDeadThread(1, 2)).start(); new Thread(new TestDeadThread(2, 1)).start(); } } }

点击检查死锁，会出现死锁的详情。 thread-5的锁被thread-10持有，相反亦是，造成死锁。