Java多线程增强+反射+代理

Ø java多线程增强

1. java多线程基本知识

1.1进程介绍

不管是我们开发的应用程序，还是我们运行的其他的应用程序，都需要先把程序安装在本地的硬盘上。然后找到这个程序的启动文件，启动程序的时候，其实是电脑把当前的这个程序加载到内存中，在内存中需要给当前的程序分配一段独立的运行空间。这片空间就专门负责当前这个程序的运行。

不同的应用程序运行的过程中都需要在内存中分配自己独立的运行空间，彼此之间不会相互的影响。我们把每个独立应用程序在内存的独立空间称为当前应用程序运行的一个进程。

进程：它是内存中的一段独立的空间，可以负责当前应用程序的运行。当前这个进程负责调度当前程序中的所有运行细节。

1.2 线程介绍

启动的QQ聊天软件，需要和多个人进行聊天。这时多个人之间是不能相互影响，但是它们都位于当前QQ这个软件运行时所分配的内容的独立空间中。

在一个进程中，每个独立的功能都需要独立的去运行，这时又需要把当前这个进程划分成多个运行区域，每个独立的小区域（小单元）称为一个线程。

线程：它是位于进程中，负责当前进程中的某个具备独立运行资格的空间。

进程是负责整个程序的运行，而线程是程序中具体的某个独立功能的运行。一个进程中至少应该有一个线程。

1.3多线程介绍

现在的操作系统基本都是多用户，多任务的操作系统。每个任务就是一个进程。而在这个进程中就会有线程。

真正可以完成程序运行和功能的实现靠的是进程中的线程。

多线程：在一个进程中，我们同时开启多个线程，让多个线程同时去完成某些任务（功能）。

多线程的目的：提高程序的运行效率。

1.4 多线程运行的原理

cpu在线程中做时间片的切换。

其实真正电脑中的程序的运行不是同时在运行的。CPU负责程序的运行，而CPU在运行程序的过程中某个时刻点上，它其实只能运行一个程序。而不是多个程序。而CPU它可以在多个程序之间进行高速的切换。而切换频率和速度太快，导致人的肉看看不到。

每个程序就是进程，而每个进程中会有多个线程，而CPU是在这些线程之间进行切换。

了解了CPU对一个任务的执行过程，我们就必须知道，多线程可以提高程序的运行效率，但不能无限制的开线程。

1.5实现线程的两种方式

1、继承Thread的原理

import java.util.Random;

public class MyThreadWithExtends extends Thread {
   String flag;
   
   public MyThreadWithExtends(String flag){
      this.flag = flag;
   }
   
   

   @Override
   public void run() {
      // 获取当前线程的线程名
      String tname = Thread.currentThread().getName();
      System.out.println(tname+"线程的run方法被调用……");
      Random random = new Random();
      for(int i=0;i<20;i++){
         try {
            Thread.sleep(random.nextInt(10)*100);
            System.out.println(tname+ "...."+ flag);
         } catch (InterruptedException e) {
            e.printStackTrace();
         }
      }
   }

   public static void main(String[] args) {
      Thread thread1 = new MyThreadWithExtends("a");
      Thread thread2 = new MyThreadWithExtends("b");
      thread1.start();
      thread2.start();
      /**
       * 如果是调用thread的run方法，则只是一个普通的方法调用，不会开启新的线程
       */
//    thread1.run();
//    thread2.run();
   }
}

2、声明实现 Runnable 接口的类

public class MyThreadWithImpliment implements Runnable {
   int x;

   public MyThreadWithImpliment(int x) {
      this.x = x;
   }

   @Override
   public void run() {
      String name = Thread.currentThread().getName();
      System.out.println("线程" + name + "的run方法被调用……");
      for (int i = 0; i < 10; i++) {
         System.out.println(x);
         try {
            Thread.sleep(100);
            
         } catch (InterruptedException e) {
            e.printStackTrace();
         }
      }
   }

   public static void main(String[] args) {
      Thread thread1 = new Thread(new MyThreadWithImpliment(1), "thread-1");
      Thread thread2 = new Thread(new MyThreadWithImpliment(2), "thread-2");
       thread1.start();
       thread2.start();
      // 注意调用run和调用start的区别,直接调用run，则都运行在main线程中
//    thread1.run();
//    thread2.run();
   }

3、还可以实现Callable接口

2. java同步关键词解释

2.1 synchronized

synchronized是用来实现线程同步的！！！

加同步格式：

synchronized( 需要一个任意的对象（锁） ){

代码块中放操作共享数据的代码。

}

package cn.itcast_01_mythread.thread.testThread;

public class MySynchronized {
   public static void main(String[] args) {
      final MySynchronized mySynchronized = new MySynchronized();
      final MySynchronized mySynchronized2 = new MySynchronized();
      new Thread("thread1") {
         public void run() {
            synchronized ("sb") {
            try {
               System.out.println(this.getName()+" start");
//             int i =1/0;   //如果发生异常，jvm会将锁释放
               Thread.sleep(5000);
               System.out.println(this.getName()+"醒了");
               System.out.println(this.getName()+" end");
            } catch (InterruptedException e) {
               e.printStackTrace();
            }
            }
         }
      }.start();
      new Thread("thread2") {
         public void run() {
            synchronized ("sb") {         //争抢同一把锁时，线程1没释放之前，线程2只能等待
//              synchronized (mySynchronized2) {    //如果不是一把锁，可以看到两句话同时打印
               System.out.println(this.getName()+" start");
               System.out.println(this.getName()+" end");
               
            }
         }
      }.start();
   }
}

Ø synchronized的缺陷

synchronized是java中的一个关键字，也就是说是Java语言内置的特性。

如果一个代码块被synchronized修饰了，当一个线程获取了对应的锁，并执行该代码块时，其他线程便只能一直等待，等待获取锁的线程释放锁，而这里获取锁的线程释放锁只会有两种情况：

1）获取锁的线程执行完了该代码块，然后线程释放对锁的占有；

2）线程执行发生异常，此时JVM会让线程自动释放锁。

例子1：

　　如果这个获取锁的线程由于要等待IO或者其他原因（比如调用sleep方法）被阻塞了，但是又没有释放锁，其他线程便只能干巴巴地等待，试想一下，这多么影响程序执行效率。

　　因此就需要有一种机制可以不让等待的线程一直无期限地等待下去（比如只等待一定的时间或者能够响应中断），通过Lock就可以办到。

例子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则必须要用户去手动释放锁，如果没有主动释放锁，就有可能导致出现死锁现象。

3）线程A和B都要获取对象O的锁定，假设A获取了对象O锁，B将等待A释放对O的锁定，如果使用 synchronized ，如果A不释放，B将一直等下去，不能被中断，如果使用ReentrantLock，如果A不释放，可以使B在等待了足够长的时间以后，中断等待，而干别的事情。

Ø java.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()的正确使用方法

import java.util.ArrayList;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MyLockTest {
   private static ArrayList<Integer> arrayList = new ArrayList<Integer>();
   static Lock lock = new ReentrantLock(); // 注意这个地方
   public static <E> void main(String[] args) {
      new Thread() {
         public void run() {
            Thread thread = Thread.currentThread();
            
            lock.lock();   // 阻塞式的
            try {
               System.out.println(thread.getName() + "得到了锁");
               Thread.sleep(10000);
               for (int i = 0; i < 5; i++) {
                  arrayList.add(i);
               }
            } catch (Exception e) {
               // TODO: handle exception
            } finally {
               System.out.println(thread.getName() + "释放了锁");
               lock.unlock();
            }

         };
      }.start();
      
      new Thread() {
         public void run() {
            Thread thread = Thread.currentThread();
            lock.lock();
            try {
               System.out.println(thread.getName() + "得到了锁");
               for (int i = 0; i < 5; i++) {
                  arrayList.add(i);
               }
            } catch (Exception e) {
               // TODO: handle exception
            } finally {
               System.out.println(thread.getName() + "释放了锁");
               lock.unlock();
            }

         };
      }.start();
   }

}

例子2，tryLock()的使用方法

/**
 * 观察现象：一个线程获得锁后，另一个线程取不到锁，不会一直等待
 * @author
 *
 */
public class MyTryLock {

   private static ArrayList<Integer> arrayList = new ArrayList<Integer>();
   static Lock lock = new ReentrantLock(); // 注意这个地方
   public static void main(String[] args) {
      
      new Thread() {
         public void run() {
            Thread thread = Thread.currentThread();
            boolean tryLock = lock.tryLock();  // 非阻塞式的
            System.out.println(thread.getName()+" "+tryLock);
            if (tryLock) {
               try {
                  System.out.println(thread.getName() + "得到了锁");
                  Thread.sleep(1000);
                  for (int i = 0; i < 5; i++) {
                     arrayList.add(i);
                  }
               } catch (Exception e) {
                  // TODO: handle exception
               } finally {
                  System.out.println(thread.getName() + "释放了锁");
                  lock.unlock();
               }
            }
         };
      }.start();

      new Thread() {
         public void run() {
            Thread thread = Thread.currentThread();
            boolean tryLock = lock.tryLock();
            System.out.println(thread.getName()+" "+tryLock);
            if (tryLock) {
               try {
                  System.out.println(thread.getName() + "得到了锁");
                  for (int i = 0; i < 5; i++) {
                     arrayList.add(i);
                  }
               } catch (Exception e) {
                  // TODO: handle exception
               } finally {
                  System.out.println(thread.getName() + "释放了锁");
                  lock.unlock();
               }
            }

         };
      }.start();
   }

}

例子3，lockInterruptibly()响应中断的使用方法：

package cn.itcast_01_mythread.thread.lock;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;


/**
 * 观察现象：如果thread-0得到了锁，阻塞。。。
 * thread-1尝试获取锁，如果拿不到，会等待，但是可以被中断等待
 * @author
 *
 */
public class MyInterruptibly {
    private Lock lock = new ReentrantLock();  
    
       public static void main(String[] args)  {
          MyInterruptibly test = new MyInterruptibly();
           MyThread thread0 = new MyThread(test);
           MyThread thread1 = new MyThread(test);
           thread0.start();
           thread1.start();
            
           try {
               Thread.sleep(2000);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
           thread1.interrupt();   //调用中断方法来测试能否中断等待中的线程
           System.out.println("=====================");
       }  
        
       public void insert(Thread thread) throws InterruptedException{
           lock.lockInterruptibly();   //注意，如果需要正确中断等待锁的线程，必须将获取锁放在外面，然后将InterruptedException抛出
           try {  
               System.out.println(thread.getName()+"得到了锁");
               long startTime = System.currentTimeMillis();
               for(    ;     ;) {
                   if(System.currentTimeMillis() - startTime >= Integer.MAX_VALUE)
                       break;
                   //插入数据
               }
           }
           finally {
               System.out.println(Thread.currentThread().getName()+"执行finally");
               lock.unlock();
               System.out.println(thread.getName()+"释放了锁");
           }  
       }
   }
    
   class MyThread extends Thread {
       private MyInterruptibly test = null;
       public MyThread(MyInterruptibly test) {
           this.test = test;
       }

       @Override
       public void run() {
           try {
               test.insert(Thread.currentThread());
           } catch (Exception e) {
               System.out.println(Thread.currentThread().getName()+"被中断");
           }
       }

}

² 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接口。

² ReentrantReadWriteLock

ReentrantReadWriteLock里面提供了很多丰富的方法，不过最主要的有两个方法：readLock()和writeLock()用来获取读锁和写锁。

下面通过几个例子来看一下ReentrantReadWriteLock具体用法。

例子1：假如有多个线程要同时进行读操作的话，先看一下synchronized达到的效果

/**
 * 一个线程又要读又要写，用synchronize来实现的话，读写操作都只能锁住后一个线程一个线程地进行
 * 
 * @author
 * 
 */
public class MySynchronizedReadWrite {

   public static void main(String[] args) {
      final MySynchronizedReadWrite test = new MySynchronizedReadWrite();

      new Thread() {
         public void run() {
            test.operate(Thread.currentThread());
         };
      }.start();

      new Thread() {
         public void run() {
            test.operate(Thread.currentThread());
         };
      }.start();

   }

   public synchronized void operate(Thread thread) {
      long start = System.currentTimeMillis();
      int i = 0;
      while (System.currentTimeMillis() - start <= 1) {
         i++;
         if (i % 4 == 0) {
            System.out.println(thread.getName() + "正在进行写操作");
         } else {
            System.out.println(thread.getName() + "正在进行读操作");
         }
      }
      System.out.println(thread.getName() + "读写操作完毕");
   }
}

运行结果：

Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行读操作
Thread-0正在进行写操作
Thread-0读写操作完毕
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行写操作

例子2：改成用读写锁的话：

/**
 * 使用读写锁，可以实现读写分离锁定，读操作并发进行，写操作锁定单个线程
 * 
 * 如果有一个线程已经占用了读锁，则此时其他线程如果要申请写锁，则申请写锁的线程会一直等待释放读锁。
 * 如果有一个线程已经占用读锁，其他线程还是申请读锁，则可以并发进行
 * 如果有一个线程已经占用了写锁，则此时其他线程如果申请写锁或者读锁，则申请的线程会一直等待释放写锁。
 * @author
 *
 */
public class MyReentrantReadWriteLock {
    private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
     
       public static void main(String[] args)  {
           final MyReentrantReadWriteLock test = new MyReentrantReadWriteLock();
            
           new Thread(){
               public void run() {
                   test.get(Thread.currentThread());
                   test.write(Thread.currentThread());
               };
           }.start();
            
           new Thread(){
               public void run() {
                   test.get(Thread.currentThread());
                   test.write(Thread.currentThread());
               };
           }.start();
            
       }  
       
       /**
        * 读操作,用读锁来锁定
        * @param thread
        */
       public void get(Thread thread) {
           rwl.readLock().lock();
           try {
               long start = System.currentTimeMillis();
                
               while(System.currentTimeMillis() - start <= 1000) {
                   System.out.println(thread.getName()+"正在进行读操作");
                   Thread.sleep(100);
               }
               System.out.println(thread.getName()+"读操作完毕");
           }catch(Exception e){} finally {
               rwl.readLock().unlock();
           }
       }

       /**
        * 写操作，用写锁来锁定
        * @param thread
        */
       public void write(Thread thread) {
           rwl.writeLock().lock();
           try {
               long start = System.currentTimeMillis();
                
               while(System.currentTimeMillis() - start <= 1) {
                   System.out.println(thread.getName()+"正在进行写操作");
               }
               System.out.println(thread.getName()+"写操作完毕");
           } finally {
               rwl.writeLock().unlock();
           }
       }
}

运行结果：并发读，单线程写

Thread-1正在进行读操作
Thread-0正在进行读操作
Thread-1正在进行读操作
Thread-1正在进行读操作
Thread-0正在进行读操作
Thread-0读操作完毕
Thread-1读操作完毕
Thread-1正在进行写操作
Thread-1正在进行写操作
Thread-1正在进行写操作
Thread-1正在进行写操作
Thread-0正在进行写操作
Thread-0正在进行写操作
Thread-0正在进行写操作
Thread-0正在进行写操作
Thread-0写操作完毕

注意：

　　不过要注意的是，如果有一个线程已经占用了读锁，则此时其他线程如果要申请写锁，则申请写锁的线程会一直等待释放读锁。

如果有一个线程已经占用了写锁，则此时其他线程如果申请写锁或者读锁，则申请的线程会一直等待释放写锁。

² Lock和synchronized的选择

1）Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现；

2）synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动通过unLock()去释放锁，则很可能造成死锁现象，因此使用Lock时需要在finally块中释放锁；

3）Lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够响应中断；

4）通过Lock可以知道有没有成功获取锁，而synchronized却无法办到。

5）Lock可以提高多个线程进行读操作的效率。

　　在性能上来说，如果竞争资源不激烈，两者的性能是差不多的，而当竞争资源非常激烈时（即有大量线程同时竞争），此时Lock的性能要远远优于synchronized。所以说，在具体使用时要根据适当情况选择。

3.java并发包

3.1 java并发包介绍

JDK5.0 以后的版本都引入了高级并发特性，大多数的特性在java.util.concurrent 包中，是专门用于多线程发编程的，充分利用了现代多处理器和多核心系统的功能以编写大规模并发应用程序。主要包含原子量、并发集合、同步器、可重入锁，并对线程池的构造提供

了强力的支持。

线程池

² 线程池的5种创建方式：

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

代码： Executors.newSingleThreadExecutor()

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

代码：Executors.newCachedThreadPool()

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

代码： Executors.newFixedThreadPool(4)

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

4、 Scheduled Thread Pool : 用来调度即将执行的任务的线程池，

代码：Executors.newScheduledThreadPool()

5、 Single Thread Scheduled Pool : 只有一个线程，用来调度执行将来的任务，代码：Executors.newSingleThreadScheduledExecutor()

² 线程池的使用

所谓给线程池提交任务，就是：

1、你将任务（业务处理逻辑）写到一个runnable或者callable的执行方法<run() | call()>

2、将这个runnable对象提交给线程池即可

提交 Runnable ，任务完成后 Future 对象返回 null

见代码：

public class ThreadPoolWithRunable {

   /**
    * 通过线程池执行线程
    * @param args
    * @throws InterruptedException
    */
   public static void main(String[] args) throws InterruptedException {
      //创建一个线程池
      ExecutorService pool = Executors.newCachedThreadPool();
      for(int i = 1; i < 50; i++){
         pool.execute(new Runnable() {
            @Override
            public void run() {
               System.out.println("thread name: " + Thread.currentThread().getName());
               try {
                  Thread.sleep(1000);
               } catch (InterruptedException e) {
                  e.printStackTrace();
               }
            }
         });
      }

      Thread.sleep(10000);
      for(int i = 1; i < 50; i++){
         pool.execute(new Runnable() {
            @Override
            public void run() {
               System.out.println("thread name: " + Thread.currentThread().getName());
               try {
                  Thread.sleep(1000);
               } catch (InterruptedException e) {
                  e.printStackTrace();
               }
            }
         });
      }
      pool.shutdown();
   }
}

提交 Callable，该方法返回一个 Future 实例表示任务的状态

见代码：

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
/**
 * callable 跟runnable的区别：
 * runnable的run方法不会有任何返回结果，所以主线程无法获得任务线程的返回值
 * 
 * callable的call方法可以返回结果，但是主线程在获取时是被阻塞，需要等待任务线程返回才能拿到结果
 * @author
 *
 */
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<String> submit = pool.submit(new Callable<String>(){
            @Override
            public String call() throws Exception {
               //System.out.println("a");
               System.out.println(Thread.currentThread().getName()+ "-->正在工作");
               Thread.sleep(5000);
               System.out.println(Thread.currentThread().getName()+ "-->工作结束");
               return "b--"+Thread.currentThread().getName();
            }           
            });
         //从Future中get结果，这个方法是会被阻塞的，一直要等到线程任务返回结果
          System.out.println("获取到结果：" + submit.get());
      } 
         pool.shutdown();

   }

}

4.java JMS技术

4.1 什么是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)。

5. JMS规范

5.1 专业技术规范

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

5.2 体系架构

JMS由以下元素组成。

JMS提供者：连接面向消息中间件的，JMS接口的一个实现。提供者可以是Java平台的JMS实现，也可以是非Java平台的面向消息中间件的适配器。

JMS客户：生产或消费基于消息的Java的应用程序或对象。

JMS生产者：创建并发送消息的JMS客户。

JMS消费者：接收消息的JMS客户。

JMS消息：包括可以在JMS客户之间传递的数据的对象

JMS队列：一个容纳那些被发送的等待阅读的消息的区域。一旦一个消息被阅读，该消息将被从队列中移走。

JMS主题：一种支持发送消息给多个订阅者的机制。

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

1、点对点或队列模型

在点对点或队列模型下，一个生产者向一个特定的队列发布消息，一个消费者从该队列中读取消息。这里，生产者知道消费者的队列，并直接将消息发送到消费者的队列。

这种模式被概括为：

只有一个消费者将获得消息

生产者不需要在接收者消费该消息期间处于运行状态，接收者也同样不需要在消息发送时处于运行状态。

每一个成功处理的消息都由接收者签收

2、发布者/订阅者模型

发布者/订阅者模型支持向一个特定的消息主题发布消息。0或多个订阅者可能对接收来自特定消息主题的消息感兴趣。在这种模型下，发布者和订阅者彼此不知道对方。这种模式好比是匿名公告板。

这种模式被概括为：

多个消费者可以获得消息

在发布者和订阅者之间存在时间依赖性。发布者需要建立一个订阅（subscription），以便客户能够订阅。订阅者必须保持持续的活动状态以接收消息，除非订阅者建立了持久的订阅。在那种情况下，在订阅者未连接时发布的消息将在订阅者重新连接时重新发布。

5.4 常用的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

5.5 代码演示

注：新版直接解压即可运行

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\win64\activemq.bat运行ActiveMQ程序。

启动ActiveMQ以后，登陆：http://localhost:8161/admin/，创建一个Queue，命名为FirstQueue。

3.运行代码

package cn.itcast_03_mq.queue

package cn.itcast_03_mq.topic

6.java反射、动态代理、sockect通信

6.1反射

通过反射的方式可以获取class对象中的属性、方法、构造函数等，一下是实例：

public class MyReflect {
   public String className = null;
   @SuppressWarnings("rawtypes")
   // Class 代表JVM中加载好的一个特定class文件
   public Class personClass = null;
   /**
    * 反射Person类
    * @throws Exception 
    */
   @Before
   public void init() throws Exception {
      className = "cn.itcast_04_reflect.Person";
      // 通过Class.forName( 类全路径字符串)，就能将这个类的class文件加载到JVM内存中
      personClass = Class.forName(className);
   }
   /**
    *获取某个class文件对象
    */
   @Test
   public void getClassName() throws Exception {
      System.out.println(personClass);
   }
   /**
    *获取某个class文件对象的另一种方式
    */
   @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  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);
      }
      //反射当前这个类的直接父类
      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());
      
      
   }

}

6.2 动态代理

在之前的代码调用阶段，我们用action调用service的方法实现业务即可。

由于之前在service中实现的业务可能不能够满足当先客户的要求，需要我们重新修改service中的方法，但是service的方法不只在我们这个模块使用，在其他模块也在调用，其他模块调用的时候，现有的service方法已经能够满足业务需求，所以我们不能只为了我们的业务而修改service，导致其他模块授影响。

那怎么办呢？

可以通过动态代理的方式，扩展我们的service中的方法实现，使得在原有的方法中增加更多的业务，而不是实际修改service中的方法，这种实现技术就叫做动态代理。

动态代理：在不修改原业务的基础上，基于原业务方法，进行重新的扩展，实现新的业务。

例如下面的例子：

1、旧业务

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

2、新业务

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

代理实现流程：

1、书写代理类和代理方法，在代理方法中实现代理Proxy.newProxyInstance

2、代理中需要的参数分别为：被代理的类的类加载器soneObjectclass.getClassLoader()，被代理类的所有实现接口new Class[] { Interface.class }，句柄方法new InvocationHandler()

3、在句柄方法中复写invoke方法，invoke方法的输入有3个参数Object proxy（代理类对象）, Method method（被代理类的方法）,Object[] args（被代理类方法的传入参数），在这个方法中，我们可以定制化的开发新的业务。

4、获取代理类，强转成被代理的接口

5、最后，我们可以像没被代理一样，调用接口的认可方法，方法被调用后，方法名和参数列表将被传入代理类的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);

}

源代码：https://github.com/JiyangM/Java_basic

Java多线程增强+反射+代理

1. java多线程基本知识

1.2 线程介绍

2. java同步关键词解释

2.2 lock

3.java并发包

3.1 java并发包介绍

4.java JMS技术

6.java反射、动态代理、sockect通信

基于 Nginx Ingress + 云效 AppStack 实现灰度发布

12款高效开源Wiki系统推荐，打造团队知识管理利器

C语言--右移左移

一个开源且全面的C#算法实战教程

dotnet 基于 DirectML 控制台运行 Phi-3 模型

自定义MyBatis插件

一款.NET开源、功能强大、跨平台的绘图库 - OxyPlot

常用的 Git 指令

鼠标控制软件有可能和虚拟机软件产生冲突

sm4加密工具类

Spark-sql 結合hive使用

使用Logstash filter grok過濾日誌文件

Kafka負載均衡、Kafka自定義Partition、Kafk文件存儲機制

Spark Streaming中的操作函數分析

Zookeeper基本使用

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結