方式一：继承Thread类；

步骤：

1）定义一个类 A继承于java.lang.Thread类；

2）在A类中覆盖Thread类中的run方法；

3）在run方法中编写需要执行的操作------run方法里的线程执行体；

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

创建线程类对象：                        A类  a  =  new  A类( );

调用线程对象的start方法：  a.start( )  //启动一个线程

注意：千万不要调用run方法。如果调用run方法好比是对象调用方法，依然还是只有一个线程，并没有开启新的线程

方式二：实现Runnable接口；

步骤：

1）定义一个类 A实现于java.lang.Runnable接口，注意A类不是线程类；

2）在A类中覆盖Runnable接口中的run方法；

3）在run方法中编写需要执行的操作------run方法里的线程执行体；

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

创建线程类对象：                        Thread  t  =  new Thread( new  A( )  );

调用线程对象的start方法：         t.start( )  

注意：千万不要调用run方法。如果调用run方法好比是对象调用方法，依然还是只有一个线程，并没有开启新的线程

1.start

使用start方法才真正实现了多线程运行，因为使用start（）方法不用等待run方法体代码执行完毕而直接继续执行下面的代码。

因为thread线程有5种状态，创建-就绪-运行-阻塞-死亡这五种，用Thread类的start()方法来启动一个线程，这时此线程处于就绪（可运行）状态，并没有运行，等到cpu空闲时，才会执行线程里面的run方法，run方法运行完毕，此线程结束。
2.run

因为run方法是thread里面的一个普通的方法，直接调用run方法，这个时候它是会运行在我们的主线程中的，程序中依然只有主线程这一个线程，其程序执行路径还是只有一条，还是要顺序执行，还是要等待run方法体执行完毕后才可继续执行下面的代码，这样就没有达到多线程的目的。
代码示例：
public class ThreadDemo {
    public static void main(String[] args){
        Thread thread1 = new Thread(new MyRunnable());
        Thread thread2 = new Thread(new MyRunnable());
        thread1.start();
        thread2.start();
    }
}

class MyRunnable implements Runnable {

    @Override
    public void run() {
        try {
            for (int i = 0; i < 10; i++) {
                System.out.println(i);
                Thread.sleep(100);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

两个线程都是使用start方法开启的，所以并不需要等待另一个完成，所以他们的执行顺序应该是并行的，我们运行看一下结果：



和我们分析的一样，那么我们改改代码，执行使用run方法，看看是否顺序执行
 public static void main(String[] args){
    Thread thread1 = new Thread(new MyRunnable());
    Thread thread2 = new Thread(new MyRunnable());
    thread1.run();
    thread2.run();
}



总结：调用start方法方可启动线程，而run方法只是thread的一个普通方法调用，还是在主线程里执行。

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);

运行效果

两者都可以触发线程执行。

但run会立即同步执行、start异步执行。

1、 start()：

用start方法来启动线程，真正实现了多线程运行，这时无需等待run方法体代码执行完毕而直接继续执行下面的代码。通过调用Thread类的start()方法来启动一个线程，这时此线程处于就绪（可运行）状态，并没有运行，一旦得到CPU时间片，就开始执行run()方法，这里方法run()称为线程体，它包含了要执行的这个线程的内容，Run()方法运行结束，此线程随即终止。

2、run()：

因为run()方法只是thread类的一个普通方法而已，如果直接调用run方法，程序中依然只有主线程这一个线程，其程序执行路径还是只有一条，还是要顺序执行，还是要等待run方法体执行完毕后才可继续执行下面的代码，这样就没有达到写线程的目的。

总结：调用start方法方可启动线程，而run方法只是thread的一个普通方法调用，还是在主线程里执行。从Java的设计上来看，不推荐使用Thread.run()启动线程，应该调用start()或者干脆交给线程池去做。