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

最新推荐文章于 2023-07-09 11:07:50 发布
最新推荐文章于 2023-07-09 11:07:50 发布
阅读量766 收藏 1
点赞数 1
分类专栏： 【JAVA】Java基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_21989939/article/details/79698144
版权

Ø 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

<transportConnectors>

       <transportConnector name="openwire" uri="tcp://localhost:61616"/>

       <transportConnector name="ssl"     uri="ssl://localhost:61617"/>

       <transportConnector name="stomp"   uri="stomp://localhost:61613"/>

      <transportConnector uri="http://localhost:8081"/>

       <transportConnector uri="udp://localhost:61618"/>

然后双击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

 

21989939
关注
专栏目录
Java核心面试知识点整理：JVM+Java集合+多线程并发+算法+Spring全家桶等29部分，详细介绍
+W❤：bjmsb2019
07-07 352
本篇文章会对面试中常遇到的Java技术点进行全面深入的总结，帮助我们在面试中更加得心应手，不参加面试的同学也能够借此机会梳理一下自己的知识体系，进行查漏补缺（阅读本文需要有一定的Java基础；若您初涉Java，可以通过这些问题建立起对Java初步的印象，待有了一定基础后再后过头来看收获会更大）。 1. Java中的原始数据类型都有哪些，它们的大小及对应的封装类是什么？ （1）boolean boolean数据类型非true即false。这个数据类型表示1 bit的信息，但是它的大小并没有精确定义..
Day22_8 Java学习之反射、多线程
weixin_43717536的博客
08-22 552
解析：1.我们在之前，学习的程序在没有跳转语句的前提下，都是由上至下依次执行，那现在想要设计一个程序，边打游戏边听歌，怎么设计？要解决上述问题,咱们得使用多进程或者多线程来解决.2.并行：指两个或多个事件在同一时刻发生（同时发生）。并发：指两个或多个事件在同一个时间段内发生。3.进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。线程。
java基础，多线程，反射
04-05
结合java最基本的多线程，反射，泛型 对java基础的学习非常有帮助
java多线程和反射机制
qq_57404736的博客
06-02 540
java的多线程和反射机制
Java反射，Java多线程
weixin_34032827的博客
08-29 165
2019独角兽企业重金招聘Python工程师标准>>> ...
Java反射，多线程
abcdint的博客
08-15 211
//反射 /*Class<?> clazz = Class.forName("cn.lpf.threadDemo.ReflectPoint"); Field fieldx = clazz.getField("x"); Field fieldy = clazz.getField("y"); Object obj = claz...
java多线程代理IP池
11-30
多线程代理IP池，一直看到有关这方面的技术，最近实现了一个。简单的来说，启动后，会一直定时的获取代理ip，并自动检测代理ip的活跃度。运用多线程的技术，在极短的时间内获取大量的ip进行筛选。架构也比较清楚，方便大家学习参考 需要主要的是，代理ip获取成功后是放在redis里面的，有关redis的参数配置在baseDB里面配置。当然对于没有开redis，我也进行处理放在了static里面。难者不会会者不难-=-。
基于Java的源码-多线程反射泛型及正则表达式学习笔记和源码.zip
07-23
《深入理解Java多线程、反射、泛型与正则表达式》 在Java编程领域，多线程、反射、泛型以及正则表达式是四个至关重要的概念，它们为开发者提供了强大的工具，使得程序更加高效、灵活且可维护。这份学习资料包括了...
Java高级特性：多线程、反射与JVM详解
通过学习这篇文档，读者不仅能掌握Java多线程的核心概念，还能深入了解并发编程、消息传递和虚拟机底层，以及如何利用反射和代理进行灵活编程。这将大大增强Java开发者的技术栈，为职业发展打下坚实基础。
Java的各种实验包括反射，算法，多线程，面试题，springboot，shiro，valid，XSS，CSRF防御
最新发布
10-03
“多线程”是Java的一大特色。Java提供了内置的并发支持，包括Thread类和Runnable接口，以及Executor框架。通过多线程，开发者可以编写出能够充分利用多核处理器性能的程序。线程同步机制如synchronized关键字、...
黑马程序员——JAVA基础——多线程、反射
gxf13283606362的博客
11-27 328
-----------android培训、java培训、java学习型技术博客、期待与您交流！------------ 一、多线程：     1、进程和线程的区别：          进程：每个进程都有独立的代码和数据空间，进程间的切换会有较大的开 销，一个进程包含1--n个线程。 　　  线程：同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序 计数器(PC)，线程切换开
第五节：Java反射、线程 线程
impermanences的博客
09-27 543
第五节：Java反射、线程 线程 1.进程：进程是程序的基本执行实体，进程是线程的容器。 线程：被称为轻量进程，是程序执行流的最小单元。线程是进程中的一个实 体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源。 线程是程序中一个单一的顺序控制流程 多线程：在单个程序中同时运行多个线程完成不同的工作，称为多线程 2.锁： Lock API: lock()：...
基于Java的实例源码-多线程反射泛型及正则表达式学习笔记和源码
m0_62396648的博客
07-09 94
通过Pattern类的compile()方法将正则表达式编译成模式对象，然后使用Matcher类的matches()方法进行匹配。上述代码中，通过Class.forName()方法动态获取MyClass类的Class对象，然后使用反射API获取构造方法并创建类的实例。接下来，通过getMethod()方法获取类的方法并调用invoke()来执行方法。通过Java反射API，我们可以获取类的构造方法、字段、方法等信息，以及动态调用类的方法。通过泛型，我们可以定义一种通用的类型，在使用时再确定具体的类型。
多线程、反射
Mr_haimeng的博客
08-04 639
【目录】线程 实现线程 死锁 反射 注解多线程：在Java思想中，将并发完成的每一件事情称为线程。java语言提供了并发机制，程序猿可以在程序中执行多个线程，每一个线程完成一个功能，并与其他线程并发执行，这种机制称为多线程。 一个简单的线程代码package com.day08.thread;public class MyThread extends Thread { @Overr
六、多线程、Java常用类、Java反射机制
weixin_30699465的博客
06-04 84
一、多线程 程序、进程、线程的概念 Java中多线程的创建和使用 实现 Runnable 接口与继承 Thread 类 Thread类的主要方法 线程的调度与设置优先级 线程的生命周期 线程的同步 线程的通信 二、Java常用类 1 字符串相关的类 String 类 StringBuffer 类 StringBuilder 类 2 JDK 8之前时间日期API ...
Java复习笔记+经验总结-06 多线程 泛型 反射
YangLong的博客
11-26 646
进程与线程: 进程是竞争计算机资源的基本单位, 线程是处理机调度的基本单位。进程是正在运行的程序, 是动态的。一个进程中包含多个线程。 注意:宏观上我们感觉多个线程并行执行, 其实是CPU时间片轮转的的结果, 线程(进程)在宏观上并行, 在微观上串行。Java中线程的创建方式: 　　1.继承Thread类, 重写run()方法。 　　2.实现Runable接口。 注意: 实际上Thread
Java基础---反射、多线程
qq_51729037的博客
02-07 394
Java基础---反射、多线程
java多线程与动态代理
woaini886353的博客
05-10 653
图在结尾 java多线程增强 java多线程基本知识 进程介绍 不管是我们开发的应用程序，还是我们运行的其他的应用程序，都需要先把程序安装在本地的硬盘上。然后找到这个程序的启动文件，启动程序的时候，其实是电脑把当前的这个程序加载到内存中，在内存中需要给当前的程序分配一段独立的运行空间。这片空间就专门负责当前这个程序的运行。 不同的应用程序运行的过程中都需要在内存中分配自己独立的运行空间，彼此之间不会相互的影响。我们把每个独立应用程序在内存的独立空间称为当前应用程序...
java反射与多线程_Java反射工作机制
weixin_36134871的博客
03-02 722
前言反射是Spring、mybatis等框架的基础，对于常写业务逻辑的同学应该算是最熟悉的陌生人，今天我们就聊聊Java的反射机制，把不熟悉变成熟悉。结论在前：1：Class对象包含类的所有信息，可以通过该对象获取到构造方法，成员变量，成员方法和接口等信息，这些信息在JVM中同样以类的形式存在2：Class对象有三种获取方法，字面量XXX.class，Object.getClass()，Class...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值