线程

一、线程

1.1进程

• 是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。

• 现代操作系统比如Mac OS X，UNIX，Linux，Windows等，都是支持“多任务”的操作系统。

  什么叫“多任务”呢？简单地说，就是操作系统可以同时运行多个任务。打个比方，你一边在用浏览器上网，一边在听MP3，一边在用Word赶作业，这就是多任务，至少同时有3个任务正在运行。还有很多任务悄悄地在后台同时运行着，只是桌面上没有显示而已。

  对于操作系统来说，一个任务就是一个进程（Process），比如打开一个浏览器就是启动一个浏览器进程，打开一个记事本就启动了一个记事本进程，打开两个记事本就启动了两个记事本进程，打开一个Word就启动了一个Word进程。

1.2线程

• 进程内部的一个独立执行单元；一个进程可以同时并发的运行多个线程，可以理解为一个进程便相当于一个单 CPU 操作系统，而线程便是这个系统中运行的多个任务。

• 有些进程还不止同时干一件事，比如Word，它可以同时进行打字、拼写检查、打印等事情。在一个进程内部，要同时干多件事，就需要同时运行多个“子任务”，我们把进程内的这些“子任务”称为线程（Thread）。

  由于每个进程至少要干一件事，所以，一个进程至少有一个线程。当然，像Word这种复杂的进程可以有多个线程，多个线程可以同时执行，多线程的执行方式和多进程是一样的，也是由操作系统在多个线程之间快速切换，让每个线程都短暂地交替运行，看起来就像同时执行一样。当然，真正地同时执行多线程需要多核CPU才可能实现。

  我们可以再电脑底部任务栏，右键----->打开任务管理器,可以查看当前任务的进程和线程：

线程理解：线程是一个程序里面不同的执行路径

每一个分支都叫做一个线程，main()叫做主分支，也叫主线程。

进程只是一个静态的概念，机器上的一个.class文件，机器上的一个.exe文件，这个叫做一个进程。程序的执行过程都是这样的：首先把程序的代码放到内存的代码区里面，代码放到代码区后并没有马上开始执行，但这时候说明了一个进程准备开始，进程已经产生了，但还没有开始执行，这就是进程，所以进程其实是一个静态的概念，它本身就不能动。平常所说的进程的执行指的是进程里面主线程开始执行了，也就是main()方法开始执行了。进程是一个静态的概念，在我们机器里面实际上运行的都是线程。

1.进程：进程是一个静态的概念
2.线程：一个进程里面有一个主线程叫main()方法，是一个程序里面的，一个进程里面不同的执行路径。
3.在同一个时间点上，一个CPU只能支持一个线程在执行。因为CPU运行的速度很快，因此我们看起来的感觉就像是多线程一样。
什么才是真正的多线程？如果你的机器是双CPU，或者是双核，这确确实实是多线程。

1.3创建线程

1. 继承Thread类创建线程类

   （1）定义Thread类的子类，并重写该类的run方法，该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体。

   （2）创建Thread子类的实例，即创建了线程对象。

   （3）调用线程对象的start()方法来启动该线程。

   class SomeThead extends Thread   { 
       public void run()   { 
        //do something here  
       }  
    } 
    
   public static void main(String[] args){
   	 SomeThread oneThread = new SomeThread();   
     	//启动线程:调用start()方法启动新开辟的线程  
   	 oneThread.start(); 
   }
   

2. 通过Runnable接口创建线程类

   （1）定义runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。

   （2）创建 Runnable实现类的实例，并依此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。

   （3）调用线程对象的start()方法来启动该线程。

   /*定义一个类用来实现Runnable接口，实现Runnable接口就表示这个类是一个线程类*/
   class SomeRunnable implements Runnable   { 
     public void run()   { 
   	 //do something here  
     }  
   } 
   
   public static void main(String[] args){
       //这里new了一个线程类的对象出来
   	Runnable oneRunnable = new SomeRunnable(); 
       //要启动一个新的线程就必须new一个Thread对象出来
       //这里使用的是Thread(Runnable target) 构造方法
   	Thread thread01 = new Thread(oneRunnable);   
       //启动新开辟的线程，新线程执行的是run()方法，新线程与主线程会一起并行执行
   	thread01.start();
   }
   

3. 通过Callable和Future创建线程

   （1）创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，并且有返回值。

   （2）创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。

   （3）使用FutureTask对象作为Thread对象的target创建并启动新线程。

   （4）调用FutureTask对象的get()方法来获得子线程执行结束后的返回值其中，Callable接口(也只有一个方法)定义如下：

   public interface Callable   { 
     V call() throws Exception;  
    } 
   
   步骤1：创建实现Callable接口的类SomeCallable(略);   
   步骤2：创建一个类对象： 
         Callable oneCallable = new SomeCallable(); 
   步骤3：由Callable创建一个FutureTask对象：   
       FutureTask oneTask = new FutureTask(oneCallable); 
     注释： FutureTask是一个包装器，它通过接受Callable来创建，它同时实现了 Future和Runnable接口。 
   步骤4：由FutureTask创建一个Thread对象：   
       Thread oneThread = new Thread(oneTask);   
   步骤5：启动线程：  
       oneThread.start();
   

4. 实现Runnable接口比继承Thread类所具有的优势：

   1. 适合多个相同的程序代码的线程去共享同一个资源。
   2. 可以避免java中的单继承的局限性。
   3. 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
   4. 线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。

   扩充：在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用java命令执行一个类的时候，实际上都会启动一个JVM，每一个JVM其实在就是在操作系统中启动了一个进程

1.4并行与并发区别

• 并行：指两个或多个事件在同一时刻发生（同时发生）。
• 并发：指两个或多个事件在同一个时间段内发生。

你吃饭吃到一半，电话来了，你一直到吃完了以后才去接，这就说明你不支持并发也不支持并行。

你吃饭吃到一半，电话来了，你停了下来接了电话，接完后继续吃饭，这说明你支持并发。 （不一定是同时的）

你吃饭吃到一半，电话来了，你一边打电话一边吃饭，这说明你支持并行。

在操作系统中，安装了多个程序，并发指的是在一段时间内宏观上有多个程序同时运行，这在单 CPU 系统中，每一时刻只能有一道程序执行，即微观上这些程序是分时的交替运行，只不过是给人的感觉是同时运行，那是因为分时交替运行的时间是非常短的。

而在多个 CPU 系统中，则这些可以并发执行的程序便可以分配到多个处理器上（CPU），实现多任务并行执行，即利用每个处理器来处理一个可以并发执行的程序，这样多个程序便可以同时执行。目前电脑市场上说的多核 CPU，便是多核处理器，核 越多，并行处理的程序越多，能大大的提高电脑运行的效率。

注意：单核处理器的计算机肯定是不能并行的处理多个任务的，只能是多个任务在单个CPU上并发运行。同理,线程也是一样的，从宏观角度上理解线程是并行运行的，但是从微观角度上分析却是串行运行的，即一个线程一个线程的去运行，当系统只有一个CPU时，线程会以某种顺序执行多个线程，我们把这种情况称之为线程调度。

二、线程安全

2.1概述

如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。

2.2实现线程安全的方式

2.2.1同步代码块。

同步代码块：synchronized关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问

synchronized(同步锁){
     需要同步操作的代码
}

同步锁:

对象的同步锁只是一个概念,可以想象为在对象上标记了一个锁.

1. 锁对象 可以是任意类型。

2. 多个线程对象 要使用同一把锁。

3. 注意:在任何时候,最多允许一个线程拥有同步锁,谁拿到锁就进入代码块,其他的线程只能在外等着(BLOCKED)。

   public class Ticket implements Runnable{
   	private int ticket = 100;
   	
   	Object lock = new Object();
   	/*
   	 * 执行卖票操作
   	 */
   	@Override
   	public void run() {
   		//每个窗口卖票的操作 
   		//窗口 永远开启 
   		while(true){
   			synchronized (lock) {
   				if(ticket>0){//有票 可以卖
   					//出票操作
   					//使用sleep模拟一下出票时间 
   					try {
   						Thread.sleep(50);
   					} catch (InterruptedException e) {
   						// TODO Auto-generated catch block
   						e.printStackTrace();
   					}
   					//获取当前线程对象的名字 
   					String name = Thread.currentThread().getName();
   					System.out.println(name+"正在卖:"+ticket--);
   				}
   			}
   		}
   	}
   }
   

2.2.2同步方法。

• 同步方法:使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外等着。
• 同步方法的锁对象默认就是字节码对象

格式：

public synchronized void method(){
   	可能会产生线程安全问题的代码
}

同步锁是谁?

​ 对于非static方法,同步锁就是this。

​ 对于static方法,我们使用当前方法所在类的字节码对象(类名.class)。

2.2.3锁机制lock

java.util.concurrent.locks.Lock机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作,同步代码块/同步方法具有的功能Lock都有,除此之外更强大,更体现面向对象。

Lock锁也称同步锁，加锁与释放锁方法化了，如下：

• public void lock():加同步锁。

• public void unlock():释放同步锁。

  优缺点:

  由于synchronized是在JVM层面实现的，因此系统可以监控锁的释放与否；而ReentrantLock是使用代码实现的，系统无法自动释放锁，需要在代码中的finally子句中显式释放锁lock.unlock()。

  另外，在并发量比较小的情况下，使用synchronized是个不错的选择；但是在并发量比较高的情况下，其性能下降会很严重，此时ReentrantLock是个不错的方案

三、线程生命周期

当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。在线程的生命周期中，有几种状态呢？在API中java.lang.Thread.State这个枚举中给出了六种线程状态：

这里先列出各个线程状态发生的条件，下面将会对每种状态进行详细解析

线程状态	导致状态发生条件
NEW(新建)	线程刚被创建，但是并未启动。还没调用start方法。
Runnable(可运行)	线程可以在java虚拟机中运行的状态，可能正在运行自己代码，也可能没有，这取决于操作系统处理器。
Blocked(锁阻塞)	当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状态；当该线程持有锁时，该线程将变成Runnable状态。
Waiting(无限等待)	一个线程在等待另一个线程执行一个（唤醒）动作时，该线程进入Waiting状态。进入这个状态后是不能自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能够唤醒。
Timed Waiting(计时等待)	同waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态。这一状态将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Thread.sleep 、Object.wait。
Teminated(被终止)	因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。

3.1线程阻塞

在某一时刻某一个线程在运行一段代码的时候，这时候另一个线程也需要运行，但是在运行过程中的那个线程执行完成之前，另一个线程是无法获取到CPU执行权的（调用sleep方法是进入到睡眠暂停状态，但是CPU执行权并没有交出去，而调用wait方法则是将CPU执行权交给另一个线程），这个时候就会造成线程阻塞。

1**.睡眠状态**：当一个线程执行代码的时候调用了sleep方法后，线程处于睡眠状态，需要设置一个睡眠时间，此时有其他线程需要执行时就会造成线程阻塞，而且sleep方法被调用之后，线程不会释放锁对象，也就是说锁还在该线程手里，CPU执行权还在自己手里，等睡眠时间一过，该线程就会进入就绪状态，典型的“占着茅坑不拉屎”；

2.等待状态：当一个线程正在运行时，调用了wait方法，此时该线程需要交出CPU执行权，也就是将锁释放出去，交给另一个线程，该线程进入等待状态，但与睡眠状态不一样的是，进入等待状态的线程不需要设置睡眠时间，但是需要执行notify方法或者notifyall方法来对其唤醒，自己是不会主动醒来的，等被唤醒之后，该线程也会进入就绪状态，但是进入仅需状态的该线程手里是没有执行权的，也就是没有锁，而睡眠状态的线程一旦苏醒，进入就绪状态时是自己还拿着锁的。等待状态的线程苏醒后，就是典型的“物是人非，大权旁落“；

3.礼让状态：当一个线程正在运行时，调用了yield方法之后，该线程会将执行权礼让给同等级的线程或者比它高一级的线程优先执行，此时该线程有可能只执行了一部分而此时把执行权礼让给了其他线程，这个时候也会进入阻塞状态，但是该线程会随时可能又被分配到执行权，这就很”中国化的线程“了，比较讲究谦让；

4.自闭状态：当一个线程正在运行时，调用了一个join方法，此时该线程会进入阻塞状态，另一个线程会运行，直到运行结束后，原线程才会进入就绪状态。这个比较像是”走后门“，本来该先把你的事情解决完了再解决后边的人的事情，但是这时候有走后门的人，那就会停止给你解决，而优先把走后门的人事情解决了；

3.2sleep和wait()区别

• sleep方法是Thread类的静态方法,wait()是Object超类的成员方法

• sleep()方法导致了程序暂停执行指定的时间，让出cpu该其他线程，但是他的监控状态依然保持者，当指定的时间到了又会自动恢复运行状态。在调用sleep()方法的过程中，线程不会释放对象锁。而当调用wait()方法的时候，线程会放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象调用notify()方法后本线程才进入对象锁定池准备

• ,sleep方法需要抛异常,wait方法不需要 为什么sleep方法需要抛异常,别问我为什么,因为:Thread类中sleep方法就已经进行了抛异常处理public static native void sleep(long millis) throws InterruptedException;

• sleep方法可以在任何地方使用,

  wait方法只能在同步方法和同步代码块中使用

四、线程池

Java里面线程池的顶级接口是java.util.concurrent.Executor，但是严格意义上讲Executor并不是一个线程池，而只是一个执行线程的工具。真正的线程池接口是java.util.concurrent.ExecutorService。

要配置一个线程池是比较复杂的，尤其是对于线程池的原理不是很清楚的情况下，很有可能配置的线程池不是较优的，因此在java.util.concurrent.Executors线程工厂类里面提供了一些静态工厂，生成一些常用的线程池。官方建议使用Executors工程类来创建线程池对象。

Executors类中有个创建线程池的方法如下：

• public static ExecutorService newFixedThreadPool(int nThreads)：返回线程池对象。(创建的是有界线程池,也就是池中的线程个数可以指定最大数量)

获取到了一个线程池ExecutorService 对象，那么怎么使用呢，在这里定义了一个使用线程池对象的方法如下：

• public Future<?> submit(Runnable task):获取线程池中的某一个线程对象，并执行

  Future接口：用来记录线程任务执行完毕后产生的结果。线程池创建与使用。

使用线程池中线程对象的步骤：

1. 创建线程池对象。

2. 创建Runnable接口子类对象。(task)

3. 提交Runnable接口子类对象。(take task)

4. 关闭线程池(一般不做)。

   public static void main(String[] args) {
           // 创建一个线程池,线程池中的线程数量为3
           ExecutorService es = Executors.newFixedThreadPool(3);
   
           // 创建任务
           MyRunnable mr = new MyRunnable();//
           MyRunnable1 mr1 = new MyRunnable1();
           MyRunnable2 mr2 = new MyRunnable2();
   
           // 提交任务
           es.submit(mr);
           es.submit(mr1);
           es.submit(mr2);
       }
   

1.可缓存线程池CachedThreadPool()

源码：

public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

根据源码可以看出：

1. 这种线程池内部没有核心线程，线程的数量是有没限制的。
2. 在创建任务时，若有空闲的线程时则复用空闲的线程，若没有则新建线程。
3. 没有工作的线程（闲置状态）在超过了60S还不做事，就会销毁。

创建方法：

ExecutorService mCachedThreadPool = Executors.newCachedThreadPool();

用法：

//开始下载
private void startDownload(final ProgressBar progressBar, final int i) {
        mCachedThreadPool.execute(new Runnable() {
            @Override
            public void run() {
                int p = 0;
                progressBar.setMax(10);//每个下载任务10秒
                while (p < 10) {
                    p++;
                    progressBar.setProgress(p);
                    Bundle bundle = new Bundle();
                    Message message = new Message();
                    bundle.putInt("p", p);
                    //把当前线程的名字用handler让textview显示出来
                    bundle.putString("ThreadName", Thread.currentThread().getName());
                    message.what = i;
                    message.setData(bundle);
                    mHandler.sendMessage(message);
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
    }

2.FixedThreadPool 定长线程池

源码：

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}

根据源码可以看出：

1. 该线程池的最大线程数等于核心线程数，所以在默认情况下，该线程池的线程不会因为闲置状态超时而被销毁。
2. 如果当前线程数小于核心线程数，并且也有闲置线程的时候提交了任务，这时也不会去复用之前的闲置线程，会创建新的线程去执行任务。如果当前执行任务数大于了核心线程数，大于的部分就会进入队列等待。等着有闲置的线程来执行这个任务。

创建方法：

//nThreads => 最大线程数即maximumPoolSize
ExecutorService mFixedThreadPool= Executors.newFixedThreadPool(int nThreads);

//threadFactory => 创建线程的方法，用得少
ExecutorService mFixedThreadPool= Executors.newFixedThreadPool(int nThreads, ThreadFactory threadFactory);

用法：

private void startDownload(final ProgressBar progressBar, final int i) {
        mFixedThreadPool.execute(new Runnable() {
            @Override
            public void run() {
               //....逻辑代码自己控制
            }
        });
    }

3.SingleThreadPool

源码：

public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>()));
}

根据源码可以看出：

1. 有且仅有一个工作线程执行任务
2. 所有任务按照指定顺序执行，即遵循队列的入队出队规则

创建方法：
ExecutorService mSingleThreadPool = Executors.newSingleThreadPool();

用法同上。

4.ScheduledThreadPool

源码：

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
    return new ScheduledThreadPoolExecutor(corePoolSize);
}

//ScheduledThreadPoolExecutor():
public ScheduledThreadPoolExecutor(int corePoolSize) {
    super(corePoolSize, Integer.MAX_VALUE,
          DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
          new DelayedWorkQueue());
}

根据源码可以看出：
DEFAULT_KEEPALIVE_MILLIS就是默认10L，这里就是10秒。这个线程池有点像是吧CachedThreadPool和FixedThreadPool 结合了一下。

1. 不仅设置了核心线程数，最大线程数也是Integer.MAX_VALUE。
2. 这个线程池是上述4个中为唯一个有延迟执行和周期执行任务的线程池。

创建：

//nThreads => 最大线程数即maximumPoolSize
ExecutorService mScheduledThreadPool = Executors.newScheduledThreadPool(int corePoolSize);

一般的执行任务方法和上面的都大同小异，我们主要看看延时执行任务和周期执行任务的方法。

//表示在3秒之后开始执行我们的任务。
mScheduledThreadPool.schedule(new Runnable() {
            @Override
            public void run() {
            //....
            }
        }, 3, TimeUnit.SECONDS);

//延迟3秒后执行任务，从开始执行任务这个时候开始计时，每7秒执行一次不管执行任务需要多长的时间。 
mScheduledThreadPool.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
             //....
            }
        },3, 7, TimeUnit.SECONDS);

/**延迟3秒后执行任务，从任务完成时这个时候开始计时，7秒后再执行，
*再等完成后计时7秒再执行也就是说这里的循环执行任务的时间点是
*从上一个任务完成的时候。
*/
mScheduledThreadPool.scheduleWithFixedDelay(new Runnable() {
            @Override
            public void run() {
             //....
            }
        },3, 7, TimeUnit.SECONDS);

五.Spring中使用多线程

我们过去实现多线程的方式通常是继承Thread类或者实现Runnable 接口，这种方式实现起来比较麻烦。spring封装了Java的多线程的实现，你只需要关注于并发事物的流程以及一些并发负载量等特性。spring通过任务执行器TaskExecutor来实现多线程与并发编程。通常使用ThreadPoolTaskExecutor来实现一个基于线程池的TaskExecutor。

1.开启线程池

首先你要实现AsyncConfigurer 这个接口，目的是开启一个线程池 ,这个步骤我们可以基于spring的配置文件实现，添加代码如下：

<!--多线程注解驱动-->
<task:annotation-driven executor="taskExecutor" />
<!--Spring线程池-->
<bean id="taskExecutor" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
    <!--核心线程数，初始同时执行线程数-->
    <property name="corePoolSize" value="10" />
    <!--最大线程数-->
    <property name="maxPoolSize" value="100" />
    <!--最大队列数-->
    <property name="queueCapacity" value="200" />
    <!--线程最大空闲时间-->
    <property name="keepAliveSeconds" value="3000" />
    <!--拒绝策略,当线程池中的线程被占用完了，并且队列数也满了，
        如果此时有新的任务要执行，使用该采取的策略处理任务-->
    <property name="rejectedExecutionHandler">
        <!--支持的策略有：
            1.AbortPolicy：该策略是线程池的默认策略。使用该策略时，如果线程池队列满了
                丢掉这个任务并且抛出RejectedExecutionException异常。
            2.DiscardPolicy：这个策略和AbortPolicy的slient(安静)版本，如果线程池队列满了，
                会直接丢掉这个任务并且不会有任何异常。
            3.DiscardOldestPolicy：这个策略从字面上也很好理解，丢弃最老的。也就是说如果队列满了，
                会将最早进入队列的任务删掉腾出空间，再尝试加入队列。
            4.CallerRunsPolicy：使用此策略，如果添加到线程池失败，那么主线程会自己去执行该任务，
                不会等待线程池中的线程去执行。就像是个急脾气的人，我等不到别人来做这件事就干脆自己干。
            5.自定义：如果以上策略都不符合业务场景，那么可以自己定义一个拒绝策略，
                只要实现RejectedExecutionHandler接口，并且实现rejectedExecution方法就可以了。
                具体的逻辑就在rejectedExecution方法里去定义就OK了。
        -->
        <bean class="java.util.concurrent.ThreadPoolExecutor.CallerRunsPolicy" />
    </property>
</bean>

2.入门使用多线程

在spring扫描的包下创建MultiThreadWork

@Component
public class MultiThreadWork {
    //加入此注解标识以下方法是开启新线程执行的-异步
    @Async
    public void doSomeThing(int i){
        try {
            System.out.println(i + "我正在处理些事..." + new Date());
            Thread.sleep(1000);
            System.out.println(i + "事情处理完了，我很开心..." + new Date());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

创建单元测试类 MultiThreadTest

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath*:spring/applicationContext-*.xml")
public class MultiThreadTest {

    @SuppressWarnings("SpringJavaInjectionPointsAutowiringInspection")
    @Autowired
    private MultiThreadWork multiThreadWork;

    @Test
    public void testMultiThread(){
        for (int i = 0; i < 5; i++) {
            System.out.println("循环" + i + "开始....");
            //多线程调用
            multiThreadWork.doSomeThing(i);
            System.out.println("循环" + i + "结束....");
        }
        try {
            //主线程阻塞，等待其它子线程执行
            System.in.read();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

查看控制台输出

循环0开始....
循环0结束....
循环1开始....
循环1结束....
循环2开始....
循环2结束....
循环3开始....
循环3结束....
循环4开始....
循环4结束....
2我正在处理些事...Sun Jun 16 14:27:29 CST 2019
3我正在处理些事...Sun Jun 16 14:27:29 CST 2019
0我正在处理些事...Sun Jun 16 14:27:29 CST 2019
4我正在处理些事...Sun Jun 16 14:27:29 CST 2019
1我正在处理些事...Sun Jun 16 14:27:29 CST 2019
1事情处理完了，我很开心...Sun Jun 16 14:27:30 CST 2019
4事情处理完了，我很开心...Sun Jun 16 14:27:30 CST 2019
3事情处理完了，我很开心...Sun Jun 16 14:27:30 CST 2019
0事情处理完了，我很开心...Sun Jun 16 14:27:30 CST 2019
2事情处理完了，我很开心...Sun Jun 16 14:27:30 CST 2019