看到这个问题第一反应是不懂，然后查询了网上的一些说法，感觉略有不一。细看之下发现大家对这个问题的分析角度不太一样，就会出现不同的结果，在这里记一下我收集来的不同的角度和自己的例子，感觉这个题目还是蛮有意思的。

首先，同步锁有两种，JVM的synchronized和JDK的ReentrantLock；
然后，多个线程访问这个类的两个方法也有不同的形式，例如访问这个类的两个方法是通过同一个类的实例对象来访问还是通过不同的类的实例对象访问；
再者，一个类的两个方法加了同步锁，这两个被同步方法也没有说明是什么样的方法。他可能是类的普通实例方法，也可能是类中Runnable对象的run方法。

看到这里也许会觉得我对于问题过于的咬文嚼字，但是我想要探讨更多的可能，不同的情形有着不同的结果，而且这些不同的情形能开拓思路，让我们看问题能多个角度，也可以帮我加深多线程的理解。如果本文中有错误或者不恰当的例子，或者代码写的不严谨不规范风格不好，都可以留言提出。

一.synchronized

1.多个线程同时访问同一个类实例对象的两个同步方法：

package synchronizedTest;

public class Example1 {
	private int num = 0 ;
	(省略getter.setter，后同)
	public synchronized void method1() {
		System.out.println("同步方法1进入");
		for(int i = 0 ; i<10 ; i++) {
			System.out.print("同步方法1:"+num+"--");
			num++ ;
		}
		System.out.println("同步方法1结束");
	}
	
	public synchronized void method2() {
		System.out.println("method2进入:");
		for(int i = 0 ; i<10 ; i++) {
			System.out.print("method2:"+num+"--");
			num++ ;
		}
		System.out.println("method2结束");
	}
	
	public static void main(String[] args) {
		final Example1 example1 = new Example1() ;
		
		Thread thread1 = new Thread(new Runnable() {
			@Override
			public void run() {
				example1.method1();
			}
		}) ;
		
		Thread thread2 = new Thread(new Runnable() {
			@Override
			public void run() {
				example1.method2();
			}
		}) ;
		try {
			thread2.join();
			thread1.join();			
			thread1.start();
			thread2.start();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}		
	}
	
}

输出结果：

method1进入
同步方法1:0--同步方法1:1--同步方法1:2--同步方法1:3--同步方法1:4--同步方法1:5--同步方法1:6--同步方法1:7--同步方法1:8--同步方法1:9--method1结束
method2进入:
method2:10--method2:11--method2:12--method2:13--method2:14--method2:15--method2:16--method2:17--method2:18--method2:19--method2结束

显然此时多个线程是不能访问同个类（的一个实例对象）的两个同步方法的

2.多个线程同时访问同一个类的不同实例对象的两个同步方法：
将上面的代码稍作修改，主函数中多new一个该类实例

final Example1 example2 = new Example1() ;

再修改thread2的run方法调用的类实例为example2

Thread thread2 = new Thread(new Runnable() {
			@Override
			public void run() {
				example2.method2();
			}
		}) ;

得到结果：

同步方法1进入
method2进入:
method2:0--method2:1--同步方法1:0--同步方法1:1--同步方法1:2--method2:2--同步方法1:3--method2:3--同步方法1:4--method2:4--同步方法1:5--method2:5--同步方法1:6--同步方法1:7--method2:6--同步方法1:8--同步方法1:9--method2:7--同步方法1结束
method2:8--method2:9--method2结束

这时候显然，多个线程是能访问同个类（的不同实例对象）的两个同步方法的。

小结：这是因为synchronized是对象锁，即线程获得的锁是施加在一个实例对象上的，如果不同的线程访问的是同一对象上的不同的同步方法，那么显然不能同时进行。
如果是不同对象上的不同的同步方法，那么就是可以同时进行的。

3.多个线程同时访问同一个类实例对象的两个Runnable对象的run方法：

package synchronizedTest;

public class Example2 {
	private int num ;
	public Runnable runnable1 = new Runnable() {
		@Override
		public void run() {
			//同步锁
			synchronized (this) {
				System.out.println("线程1进入");
				for(int i = 0 ; i < 10 ; i ++) {
					System.out.print("线程1:"+num+"--");
				}
				System.out.println("线程1结束");
			}
		}
	};
	
	public Runnable runnable2 = new Runnable() {
		@Override
		public void run() {
			//同步锁
			synchronized (this) {
				System.out.println("thread2进入");
				for(int i = 0 ; i < 10 ; i ++) {
					System.out.print("thread2:"+num+"--");
				}
				System.out.println("thread2结束");
			}
		}
	};
	
	public static void main(String[] args) {
		Example2 example = new Example2() ; //创建一个对象
		new Thread(example.runnable1).start(); //同步方法1
		new Thread(example.runnable2).start(); //同步方法2
	}
}

输出结果：

thread2进入
线程1进入
thread2:0--线程1:0--线程1:0--thread2:0--线程1:0--线程1:0--线程1:0--thread2:0--线程1:0--thread2:0--thread2:0--线程1:0--thread2:0--线程1:0--thread2:0--thread2:0--线程1:0--thread2:0--线程1:0--thread2:0--线程1结束
thread2结束

可见此时多个线程是能同时访问同个类的两个同步方法的。这是因为
synchronized(this){ //... }中锁住的不是代码块，即这个锁在run方法中，但是并不是同步了这个run方法，而是括号中的对象this,也就是说，多个线程会拿到各自的锁，就能够同时执行run方法。(在run方法前声明synchronized也是同样的效果)

new Thread(example.runnable1).start(); //同步方法1
new Thread(example.runnable2).start(); //同步方法2

打印出这个this对象，是两个不同的类实例对象：

synchronizedTest.Example2$1@65db6dfa
synchronizedTest.Example2$2@471fab

也说明了不同线程的实例对象不同，都是各自对象的锁，不可以认为是类似于例子1中的同一实例对象，而应该类似与例子2的不同类的实例对象

总结：分析synchronized同步锁的核心在于他是个对象锁，找清楚锁的对象

二.ReentrantLock锁
1.多个线程同时访问同一个类实例对象的两个同步方法：
将例子1的synchronized改为引入ReentrantLock

package ReentrantLockTest;

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

public class LockExample {
	private int num;
	private Lock lock = new ReentrantLock();

	public void method1() {
			lock.lock();
			System.out.println("同步方法1进入");
			for(int i = 0 ; i<10 ; i++) {
				System.out.print("同步方法1:"+num+"--");
				num++ ;
			}
			System.out.println("同步方法1结束");
			lock.unlock();
	}

	public void method2() {
		lock.lock();
		System.out.println("method2进入:");
		for (int i = 0; i < 10; i++) {
			System.out.print("method2:" + num + "--");
			num++;
		}
		System.out.println("method2结束");
		lock.unlock();
	}

	public static void main(String[] args) {
		final LockExample example = new LockExample() ;
		Thread thread1 = new Thread(new Runnable() {
			@Override
			public void run() {
				example.method1();
			}
		}) ;
		
		Thread thread2 = new Thread(new Runnable() {
			@Override
			public void run() {
				example.method2();
			}
		}) ;
		
		try {
			thread2.join();
			thread1.join();
			thread1.start();
			thread2.start();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

输出结果：

同步方法1进入
同步方法1:0--同步方法1:1--同步方法1:2--同步方法1:3--同步方法1:4--同步方法1:5--同步方法1:6--同步方法1:7--同步方法1:8--同步方法1:9--同步方法1结束
method2进入:
method2:10--method2:11--method2:12--method2:13--method2:14--method2:15--method2:16--method2:17--method2:18--method2:19--method2结束

可见此时多个线程是不能访问同个类（的一个实例对象）的两个同步方法的

2.多个线程同时访问同一个类的不同实例对象的两个同步方法：
修改main函数的即可：

public static void main(String[] args) {
		final LockExample example1 = new LockExample() ;//两个实例
		final LockExample example2 = new LockExample() ;
		Thread thread1 = new Thread(new Runnable() {
			@Override
			public void run() {
				example1.method1(); //实例1的同步方法1
			}
		}) ;
		
		Thread thread2 = new Thread(new Runnable() {
			@Override
			public void run() {
				example2.method2();//实例2的同步方法2
			}
		}) ;
		
		try {
			thread2.join();
			thread1.join();
			thread1.start();
			thread2.start();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

输出结果：

同步方法1进入
method2进入:
同步方法1:0--method2:0--method2:1--同步方法1:1--method2:2--同步方法1:2--同步方法1:3--method2:3--同步方法1:4--method2:4--同步方法1:5--同步方法1:6--method2:5--同步方法1:7--method2:6--同步方法1:8--同步方法1:9--同步方法1结束
method2:7--method2:8--method2:9--method2结束

可见，多个线程是能访问同个类（的不同实例对象）的两个同步方法的。

总结：ReentrantLock和synchronized的前两个例子结论都相同

3.多个线程同时访问同一个类实例对象的两个Runnable对象的run方法：

package ReentrantLockTest;

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

public class Lockexample2 {

	private int num;
	private Lock lock = new ReentrantLock();
	
	public Runnable runnable1 = new Runnable() {
		@Override
		public void run() {
			lock.lock();//上锁
			System.out.println("线程1进入");
			for(int i = 0 ; i < 10 ; i ++) {
				System.out.print("线程1:"+num+"--");				
			}
			System.out.println("线程1结束");
			lock.unlock();
		}
	};
	
	public Runnable runnable2 = new Runnable() {
		@Override
		public void run() {
			lock.lock();//上锁
			System.out.println("thread2进入");
			for(int i = 0 ; i < 10 ; i ++) {
				System.out.print("thread2:"+num+"--");
			}
			System.out.println("thread2结束");
			lock.unlock();
		}
	};
	
	public static void main(String[] args) {
		Lockexample2 example = new Lockexample2();
		new Thread(example.runnable1).start(); 
		new Thread(example.runnable2).start(); 
		
	}
}

输出结果：

线程1进入
线程1:0--线程1:0--线程1:0--线程1:0--线程1:0--线程1:0--线程1:0--线程1:0--线程1:0--线程1:0--线程1结束
thread2进入
thread2:0--thread2:0--thread2:0--thread2:0--thread2:0--thread2:0--thread2:0--thread2:0--thread2:0--thread2:0--thread2结束

这里可以看到，与synchronized的第三个例子出现了不同的结果。在这个地方，ReentrantLock不允许多线程同时访问一个类的不同同步方法。
这里要注意的是ReentrantLock与synchronized不同，ReentrantLock的实现方式是要先创建ReentrantLock对象，然后用这个对象的方法来上锁。而一个类的实例中只有一个ReentrantLock对象：

private Lock lock = new ReentrantLock();

而本例中，线程的创建是建立在同一个类实例上的：

Lockexample2 example = new Lockexample2();
new Thread(example.runnable1).start(); 
new Thread(example.runnable2).start(); 

因此，ReentrantLock对象lock是同一个，因此第一个线程进入同步方法1后就获取了锁，第二个线程无法获取这个锁，只能等待。

如果换成是两个实例对象：

public static void main(String[] args) {
		Lockexample2 example = new Lockexample2();
		Lockexample2 example2 = new Lockexample2();
		new Thread(example.runnable1).start(); 
		new Thread(example2.runnable2).start(); 
		
	}

输出结果

线程1进入
thread2进入
线程1:0--线程1:0--线程1:0--线程1:0--thread2:0--线程1:0--thread2:0--thread2:0--thread2:0--thread2:0--thread2:0--thread2:0--thread2:0--线程1:0--thread2:0--线程1:0--线程1:0--thread2:0--线程1:0--thread2结束
线程1:0--线程1结束

可见不同的实例对象中是不同的ReentrantLock对象，因此可以同时访问

小结：ReentrantLock锁的核心在与ReentrantLock对象是不是同一个

三.结论
重新看看这个问题：一个类中的两个方法都加了同步锁，多个线程能同时访问这个类的两个方法吗？

现在应该比较清楚了，这个问题要分成synchronized和ReentrantLock两个情况：

一.对于synchronized
1.一个类中的两个方法都加了同步锁，多个线程不能同时访问这个类的同一实例对象的两个方法
2.一个类中的两个方法都加了同步锁，多个线程能同时访问这个类的不同实例对象的两个方法
3.一个类中的两个方法**（Runnable的run方法）都加了同步锁，多个线程能**同时访问这个类的两个方法（不论是不是同一实例对象）

二.对于ReentrantLock
1.一个类中的两个方法都加了同步锁，多个线程不能同时访问这个类的同一实例对象的两个方法（不论同步加在实例方法中或是run方法中）
2.一个类中的两个方法都加了同步锁，多个线程能同时访问这个类的不同实例对象的两个方法（不论同步加在实例方法中或是run方法中）

java开启新线程的三种方法：

方法1：继承Thread类

1）：定义bai一个继承自Java.lang.Thread类的du类A.

2）：覆盖zhiA类Thread类中的run方法。

3）：我们编写需要在run方法中执行的操作：run方法中的代码，线程执行体。

4）：在main方法（线程）中，创建一个线程对象并启动线程。

(1)创建线程类对象:                

A类   a  =  new   A类();

(2)调用线程对象的start方法:    

a.start();//启动一个线程

注意：不要调用run方法。如果run方法被称为对象调用方法，则仍然只有一个线程，并且没有启动新线程。

创建启动线程实例：

//定义一个类A 继承java.lang.Thread
class A extends Thread{
    //A类 覆盖Thread类中的 run方法
    @Override
    public void run(){
        //在run方法填写要执行的操作
        for (int j = 0 ;j<10;j++){
            System.out.println("执行方法A的逻辑"+j);
        }
     }
}

public Class B{
    public static void main(String[] args){
        for (int i = 0;i<50 ;i++){
            System.out.println(i);
            if(i==10){
                // 在线程中重开一个线程执行其他操作
                A a = new A();
                a.start();
            }
            try {
                if (i==10){
                    Thread.sleep(1000);
                }
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}

方法2：实现Runnable接口

1）：定义要在java.lang.Runnable接口中实现的类A.请注意，A类不是线程类。

2）：覆盖A类Runnable接口中的run方法。

3）：我们编写需要在run方法中执行的操作：在run方法中，线程执行。

4）：在main方法（线程）中，创建一个线程对象并启动线程。

(1)创建线程类对象:

Thread  t = new Thread(new  A());    

(2)调用线程对象的start方法:

t.start();

代码实例：

//定义一个类C 实现java.lang.Runnable 接口 C类不是线程类
class C implements Runnable{
    //C类 覆盖Runnable接口中的 run方法
    @Override
    public void run(){
        //在run方法填写要执行的操作
        for (int j = 0 ;j<10;j++){
            System.out.println("执行方法C的逻辑"+j);
        }
    }
}

public Class B{

    public static void main(String[] args){
        for (int i = 0;i<100 ;i++){
            System.out.println(i);
            if(i==10){
                // 在线程中重开一个线程执行其他操作
                C c = new C();
                Thread t = new Thread(c);
                t.start();
            }
            try {
                if (i==10){
                    System.out.println(Thread.currentThread().getName());
                    Thread.sleep(1000);
                }
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}

方法3：直接在函数体使用

    public static void main(String[] args){

        for (int i=0;i<20;i++){
            System.out.println(i);
            if(i==10){

                Thread thread = new Thread(new Runnable() {
                    @Override
                    public void run() {
                        for(int j=0;j<10;j++){
                            System.out.println("j"+j);
                        }
                    }
                });
                thread.start();

                try {
                    if (i==10){
                        System.out.println(Thread.currentThread().getName());
                        Thread.sleep(1000);
                    }
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
        }

    }

弊端：

1、每次都要new thread,新建了一个对象，导致对象性能差。

2、线程缺乏统一管理，可能无限制新建线程，相互之间出现竞争，极可能占用过多系统资源导致死机或者oom。

3、缺乏更多功能，比如：定时定时执行，定期执行，线程中断。

相比new Thread而言，Java提供的四种线程池的好处在于：

　　　①可复用存在的线程，减少对象的创建、消亡，性能较高。

　　　②有效控制并发线程数，提高了系统资源的使用率，避免了过多争夺系统资源，导致的堵塞。

　　　③提供了定时执行、定期执行、单线程、并发数控制等功能。

Java通过Executors提供了四种线程池

•       newCachedThreadPool 创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。线程池的规模不存在限制。
•       newFixedThreadPool 创建一个固定长度线程池，可控制线程最大并发数，超出的线程会在队列中等待。
•       newScheduledThreadPool 创建一个固定长度线程池，支持定时及周期性任务执行。
•       newSingleThreadPool 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

 newCachedThreadPool:

创建一个可缓存的线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，如无回收，则新建线程

ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
  for(int i=0; i<10;i++){
     final int index=i;
      try{
             Thread.sleep(index*1000);
          }catch(InterruptedException e){
                e.printStackTrace();
          }
           cachedThreadPool.execute(new Runnable(){
                  @override
                      public  void  run(){
                             System.out.println(index);
                    }
            });
   }        

newFixedThreadPool:

创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待，定长线程池的大小最好根据系统资源进行设置。

ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
for (int i = 0; i < 10; i++) {
    final int index = i;
    fixedThreadPool.execute(new Runnable() {

        @Override
        public void run() {
            try {
                System.out.println(index);
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    });
}

newScheduledThreadPool:

创建一个定长线程池，支持定时及周期性任务执行，ScheduledExecutorService比Timer更安全，功能更强大。

ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
scheduledThreadPool.schedule(new Runnable() {

    @Override
    public void run() {
        System.out.println("delay 3 seconds");
    }
}, 3, TimeUnit.SECONDS);
此表示为延迟3秒执行
scheduledThreadPool.scheduleAtFixedRate(new Runnable() {

    @Override
    public void run() {
        System.out.println("delay 1 seconds, and excute every 3 seconds");
    }
}, 1, 3, TimeUnit.SECONDS);
此表示为延迟1秒后每3秒执行一次

newSingleThreadPool:

创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序执行

ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
for (int i = 0; i < 10; i++) {
    final int index = i;
    singleThreadExecutor.execute(new Runnable() {

        @Override
        public void run() {
            try {
                System.out.println(index);
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    });
}

newCachedThreadPool 特点：

1.核心线程数为零    2.最大线程数为无限  3.无任务时，线程存活的最大时间为60s  4.任务队列为同步移交队列，该队列没有缓冲区，即不会有任务会在该队列中排队，每当有任务要入队时，队列都会将任务移交给一个可用的线程

为什么叫缓存线程池，类比于redis缓存：

前者缓存的是频繁要用到的线程；后者缓存的是频繁要用到的数据

前者通过缓存线程，避免了每次执行任务都要创建、销毁线程的开销；后者通过缓存数据，避免了每次用到数据都要操作db

两者都有缓存失效的时间，前者对应keepAliveTime参数，超过该参数对应的时间后，销毁线程；后者当缓存对应的真实数据被修改时，缓存失效，清除数据

为了尽量重复利用缓存的线程，而不是每次要执行任务时创建新的线程，应尽量使执行任务的时间小于keepAliveTime参数，默认是60s

因为是一个“缓存”线程池，没有缓存可以永久有效，因此核心线程数为0。因此任务队列的缓冲区应为空，否则即便系统有可用的线程资源，当有新的任务时也不会被执行，而是进入任务队列排队直至队列满，这显然是不合理的。同样由于队列缓冲区为空，每来一个任务时，都会在必要时新建线程执行任务，这就有可能导致大量的线程被创建，进而系统瘫痪。

１　newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。Executors.newCachedThreadPool(); 缺点：大家一般不用是因为newCachedThreadPool 可以无线的新建线程，容易造成堆外内存溢出，因为它的最大值是在初始化的时候设置为 Integer.MAX_VALUE，一般来说机器都没那么大内存给它不断使用。当然知道可能出问题的点，就可以去重写一个方法限制一下这个最大值
２　newFixedThreadPool  Executors.newFixedThreadPool(3);创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。定长线程池的大小最好根据系统资源进行设置。如Runtime.getRuntime().availableProcessors()。可参考PreloadDataCache。其实newFixedThreadPool()在严格上说并不会复用线程，每运行一个Runnable都会通过ThreadFactory创建一个线程
３　newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。Executors.newScheduledThreadPool(5);与Timer 对比：Timer 的优点在于简单易用，但由于所有任务都是由同一个线程来调度，因此所有任务都是串行执行的，同一时间只能有一个任务在执行，前一个任务的延迟或异常都将会影响到之后的任务（比如：一个任务出错，以后的任务都无法继续）。
ScheduledThreadPoolExecutor的设计思想是，每一个被调度的任务都会由线程池中一个线程去执行，因此任务是并发执行的，相互之间不会受到干扰。需要注意的是，只有当任务的执行时间到来时，ScheduedExecutor 才会真正启动一个线程，其余时间 ScheduledExecutor 都是在轮询任务的状态。
通过对比可以发现ScheduledExecutorService比Timer更安全，功能更强大，在以后的开发中尽可能使用ScheduledExecutorService(JDK1.5以后)替代Timer
４　newSingleThreadExecutor Executors.newSingleThreadExecutor()　创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。现行大多数GUI程序都是单线程的。Android中单线程可用于数据库操作，文件操作，应用批量安装，应用批量删除等不适合并发但可能IO阻塞性及影响UI线程响应的操作。

下面举一个newFixedThreadPool 应用示例：

import AThreadService;

//调用自己写好的异步处理逻辑的方法
public A {
    @Autowired
  	private AThreadService AThreadService;
    public static void main (String [] args){
        AThreadService.AThread((String)A,(Object)B, (String)C);
    }
}


// 接口
public interface AThreadService {
	/**
	 * 方法名称: AThread
	 * @throws
	 */
	public void  AThread(String A, Object B, String C);
	
}

//实现类
public class AThreadSpringImpl  implements AThreadService{

	@Autowired
	private AService AService;
	
    //线程根据实际情况设置大小
	private static final ExecutorService AThreadPool = Executors.newFixedThreadPool(10);

	public void AThread(String A, Object B,String C) {
		// TODO Auto-generated method stub
		AThread aThread = new AThread(A,B,C);
		AThread.setAService(AService);
		AThreadPool.execute(AThread);
	}
	
}

//线程类实现runable接口
public class AThread implements Runnable {
	
	private Log log = LogFactory.getLog(AThread.class);
	
	private static final long serialVersionUID = 1L;

	private String A;
	private Object B;
	private String C;
	private AService AService;
	
	public AService AService() {
		return aService;
	}

	public void setAService(AService aService) {
		this.aService = aService;
	}

    public  AThread(String A, Object B, String C)
    {
     this.A=A;
     this.B=B;
     this.C=C;
    }
    
    public void run() {
		// TODO Auto-generated method stub
    	log.info("-----------开始----------");
    	
		aService.afunction(A, B, C);
		
		log.info("-----------结束----------");
	}

}

// 实现类实现方法
public class AServiceSpringImpl implements AService {
	 
	/** 
	 *  
	 * 方法名称: afunction 
	 * @throws 
	 */ 
	public void afunction(String A,Object B,String C){ 
         
        //Do something;
        System.out.println("业务逻辑");
	} 
} 

    在《阿里巴巴java开发手册》中指出了线程资源必须通过线程池提供，不允许在应用中自行显示的创建线程，这样一方面是线程的创建更加规范，可以合理控制开辟线程的数量；另一方面线程的细节管理交给线程池处理，优化了资源的开销。而线程池不允许使用Executors去创建，而要通过ThreadPoolExecutor方式，这一方面是由于jdk中Executor框架虽然提供了如newFixedThreadPool()、newSingleThreadExecutor()、newCachedThreadPool()等创建线程池的方法，但都有其局限性，不够灵活；另外由于前面几种方法内部也是通过ThreadPoolExecutor方式实现，使用ThreadPoolExecutor有助于大家明确线程池的运行规则，创建符合自己的业务场景需要的线程池，避免资源耗尽的风险。

    详细内容参考：https://www.cnblogs.com/dafanjoy/p/9729358.html

    线程池不允许使用Executors去创建，而是通过ThreadPoolExecutor的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。 说明：Executors返回的线程池对象的弊端如下：
1）FixedThreadPool和SingleThreadPool:
  允许的请求队列长度为Integer.MAX_VALUE，可能会堆积大量的请求，从而导致OOM。
2）CachedThreadPool:
  允许的创建线程数量为Integer.MAX_VALUE，可能会创建大量的线程，从而导致OOM。
            
Positive example 1：
    //org.apache.commons.lang3.concurrent.BasicThreadFactory
    ScheduledExecutorService executorService = new ScheduledThreadPoolExecutor(1,
        new BasicThreadFactory.Builder().namingPattern("example-schedule-pool-%d").daemon(true).build());
       
        
            
Positive example 2：
    ThreadFactory namedThreadFactory = new ThreadFactoryBuilder()
        .setNameFormat("demo-pool-%d").build();

    //Common Thread Pool
    ExecutorService pool = new ThreadPoolExecutor(5, 200,
        0L, TimeUnit.MILLISECONDS,
        new LinkedBlockingQueue<Runnable>(1024), namedThreadFactory, new ThreadPoolExecutor.AbortPolicy());

    pool.execute(()-> System.out.println(Thread.currentThread().getName()));
    pool.shutdown();//gracefully shutdown
       
        
            
Positive example 3：
    <bean id="userThreadPool"
        class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
        <property name="corePoolSize" value="10" />
        <property name="maxPoolSize" value="100" />
        <property name="queueCapacity" value="2000" />

    <property name="threadFactory" value= threadFactory />
        <property name="rejectedExecutionHandler">
            <ref local="rejectedExecutionHandler" />
        </property>
    </bean>
    //in code
    userThreadPool.execute(thread);