1.概述

在JAVA中，用Thread类代表线程，所有线程对象，都必须是Thread类或者Thread类子类的实例。每个线程的任务就是执行一段顺序执行的代码，JAVA使用线程执行体来容纳这段代码。所以，我们创建线程时，主要是根据实际需求，编写放入线程执行体的代码。

2.创建线程的五种方式

（1）继承Thread类实现多线程

通过继承Thread类来创建并启动多线程的步骤如下：

a.定义一个类继承Thread类，并重写Thread类的run()方法，run()方法的方法体就是线程要完成的任务，因此把run()称为线程的执行体；
b.创建该类的实例对象，即创建了线程对象；
c.调用线程对象的start()方法来启动线程；

代码示例如下：

public class MyThread extends Thread {
	public MyThread() {
		
	}
	public void run() {
		for(int i=0;i<10;i++) {
			System.out.println(Thread.currentThread()+":"+i);
		}
	}
	public static void main(String[] args) {
		MyThread mThread1=new MyThread();
		MyThread mThread2=new MyThread();
		MyThread myThread3=new MyThread();
		mThread1.start();
		mThread2.start();
		myThread3.start();
	}
}

Thread.currentThread()：获得当前线程

（2）通过实现Runnable接口创建线程类

通过实现Runnable接口创建并启动线程步骤如下：

a.定义一个类实现Runnable接口;
b.创建该类的实例对象obj;
c.将obj作为构造器参数传入Thread类实例对象，这个对象才是真正的线程对象；
d.调用线程对象的start()方法启动该线程；

注意：start方法是Thread类的方法。

代码示例如下：

public class MyThread implements Runnable{
	public static int count=20;
	public void run() {
		while(count>0) {
			try {
				Thread.sleep(200);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName()+"-当前剩余票数:"+count--);
		}
	}
	public static void main(String[] args) {
		MyThread Thread1=new MyThread();
		Thread mThread1=new Thread(Thread1,"线程1");
		Thread mThread2=new Thread(Thread1,"线程2");
		Thread mThread3=new Thread(Thread1,"线程3");
		mThread1.start();
		mThread2.start();
		myThread3.start();
	}
}

Thread.sleep(200)：让当前线程沉睡200毫秒
Thread.currentThread().getName()：获得当前线程的名称

继承Thread和实现Runnable接口的区别

a.实现Runnable接口避免多继承局限（Java只支出单继承，继承Thread类，就不能在继承其它类）
b.实现Runnable()可以更好的体现共享的概念（多个线程执行同一个线程执行类实例，实现数据的共享）

（3）通过Callable和Future接口创建线程

通过这两个接口创建线程，你要知道这两个接口的作用，下面我们就来了解这两个接口：通过实现Runnable接口创建多线程时，Thread类的作用就是把run()方法包装成线程的执行体，那么，是否可以直接把任意方法都包装成线程的执行体呢？从JAVA5开始，JAVA提供提供了Callable接口，该接口是Runnable接口的增强版，Callable接口提供了一个call()方法可以作为线程执行体，但call()方法比run()方法功能更强大，call()方法的功能的强大体现在：

a.call()方法可以有返回值；
b.call()方法可以声明抛出异常；

从这里可以看出，完全可以提供一个Callable对象作为Thread的target，而该线程的线程执行体就是call()方法。但问题是：Callable接口是JAVA新增的接口，而且它不是Runnable接口的子接口，所以Callable对象不能直接作为Thread的target。还有一个原因就是：call()方法有返回值，call()方法不是直接调用，而是作为线程执行体被调用的，所以这里涉及获取call()方法返回值的问题。

于是，JAVA5提供了Future接口来代表Callable接口里call()方法的返回值，并为Future接口提供了一个FutureTask实现类，该类实现了Future接口，并实现了Runnable接口，所以FutureTask可以作为Thread类的target，同时也解决了Callable对象不能作为Thread类的target这一问题。

通过Callable和Future接口创建并启动线程步骤如下：

a.创建Callable接口实现类，并实现call()方法，该方法将作为线程执行体，且该方法有返回值，再创建Callable实现类的实例；
b.使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值；
c.使用FutureTask对象作为Thread对象的target创建并启动新线程；
d.调用FutureTask对象的get()方法来获得子线程执行结束后的返回值。

代码示例如下：

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
 
public class MyThread implements Callable<String> {
	private int count = 20;
 
	@Override
	public String call() throws Exception {
		for (int i = count; i > 0; i--) {
//			Thread.yield();
			System.out.println(Thread.currentThread().getName()+"当前票数：" + i);
		}
		return "sale out";
	} 
 
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		Callable<String> callable  =new MyThread();
		FutureTask <String>futureTask=new FutureTask<>(callable);
		Thread mThread=new Thread(futureTask);
		Thread mThread2=new Thread(futureTask);
		Thread mThread3=new Thread(futureTask);
//		mThread.setName("hhh");
		mThread.start();
		mThread2.start();
		mThread3.start();
		System.out.println(futureTask.get());
		
	}
}

futureTask.get()：获得线程的返回值

（4）创建匿名线程

a.第一种

       new Thread() {
			
			@Override
			public void run() {
				System.out.println("我的线程执行了2");
			}
		}.start();

b.第二种

       new Thread(new Runnable() {
			
			@Override
			public void run() {
				System.out.println("我的线程执行了5");
			}
		}).start();

（5）通过线程池启动多线程
通过Executor 的工具类可以创建三种类型的普通线程池

a.FixThreadPool(int n); 固定大小的线程池
使用于为了满足资源管理需求而需要限制当前线程数量的场合。使用于负载比较重的服务器。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
 
public class Test {
	public static void main(String[] args) {
		ExecutorService ex=Executors.newFixedThreadPool(5);
		
		for(int i=0;i<5;i++) {
			ex.submit(new Runnable() {
				
				@Override
				public void run() {
					for(int j=0;j<10;j++) {
						System.out.println(Thread.currentThread().getName()+j);
					}
					
				}
			});
		}
		ex.shutdown();
	}	
}

b.SingleThreadPoolExecutor :单线程池
需要保证顺序执行各个任务的场景

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
 
public class Test {
	public static void main(String[] args) {
		ExecutorService ex=Executors.newSingleThreadExecutor();
		
		for(int i=0;i<5;i++) {
			ex.submit(new Runnable() {
				
				@Override
				public void run() {
					for(int j=0;j<10;j++) {
						System.out.println(Thread.currentThread().getName()+j);
					}
					
				}
			});
		}
		ex.shutdown();
	}	
}

c.CashedThreadPool(); 缓存线程池
当提交任务速度高于线程池中任务处理速度时，缓存线程池会不断的创建线程
适用于提交短期的异步小程序，以及负载较轻的服务器

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
 
public class Test {
	public static void main(String[] args) {
		ExecutorService ex=Executors.newCachedThreadPool();
		
		for(int i=0;i<5;i++) {
			ex.submit(new Runnable() {
				
				@Override
				public void run() {
					for(int j=0;j<10;j++) {
						System.out.println(Thread.currentThread().getName()+j);
					}
					
				}
			});
		}
		ex.shutdown();
	}	
}

3.创建线程的几种方式对比

通过继承Thread类实现多线程：

优点：
a.实现起来简单，而且要获取当前线程，无需调用Thread.currentThread()方法，直接使用this即可获取当前线程；

缺点：
a.线程类已经继承Thread类了，就不能再继承其他类；
b.多个线程不能共享同一份资源（如前面分析的成员变量 i ）；

通过实现Runnable接口或者Callable接口实现多线程：

优点：
a.线程类只是实现了接口，还可以继承其他类；
b.多个线程可以使用同一个target对象，适合多个线程处理同一份资源的情况。

缺点：
a.通过这种方式实现多线程，相较于第一类方式，编程较复杂；
b.要访问当前线程，必须调用Thread.currentThread()方法。

注意：多数情况下使用线程池来创建线程