线程的创建方式

 注意：每个线程都是一个线程Thread对象

  启动线程使用方法  :    start()

 方式一：继承Thread类

public class Demo{
	public static void main(String[] args) {
		SubThread t1 = new SubThread("【线程甲】");
		SubThread t2 = new SubThread("【线程乙】");

		t1.start();
		t2.start();			
	}

}
class SubThread extends Thread{
	//为线程命名
    public SubThread(String name) {
    	super(name);
    }
	@Override
	public void run() {
		for(char i = 'A';i<'Z';i++) {
			System.out.printf("%s:%c\n",this.getName(),i);
		}
	}
}

方式二：实现Runnable接口【线程执行类】

public class Demo{
	public static void main(String[] args) {
		//每个Runnable接口的实现类，封装了线程执行逻辑
		EmailTask emailTask = new EmailTask();
		
		//创建3个进程，分别发送邮件
		Thread t1 = new Thread(emailTask,"[线程1]");
		Thread t2 = new Thread(emailTask,"[线程2]");
		
		//启动线程
		t1.start();
		t2.start();
	}

}
//子类（邮件任务）
class EmailTask extends Task implements Runnable {
	@Override
	public void execute() {
		Thread currentThread = Thread.currentThread();
		String name = currentThread.getName();		
		System.out.println(name+"：使用JavaMail技术,通过SMTP协议进行传输。");
	}
	@Override
	public void run() {
		execute();	
	}
}
//父类（任务）
abstract class Task{
	public abstract void execute();
}

方式三：实现Callable接口，允许子线程返回结果、抛出异常

Eg:通过两个线程完成计算1-1000的累加和

第一步：引用Callable接口的实现类，定义不同数据范围的计算任务

第二步：使用转换类FutureTask<E>(Runnable接口的实现类)

      作用：1.转换Callable

                 2.接受返回来的值

第三步：创建3个进程

第四步：启动线程

     原理:会先调用futureTask.run()----->在其方法中调用当中的callable.call()方法

              然后将结果返回

第五步：汇总 

      调用fu吐热Task.get()方法得到结果，返回值为传入的泛型【E】

代码：

public class Demo {
	public static void main(String[] args) {
		SumTask task1 = new SumTask(1,300);
		SumTask task2 = new SumTask(301,600);
		SumTask task3 = new SumTask(601,1000);

		FutureTask<Integer> futureTask1 = new FutureTask<Integer>(task1);
		FutureTask<Integer> futureTask2 = new FutureTask<Integer>(task2);
		FutureTask<Integer> futureTask3 = new FutureTask<Integer>(task3);
	
		Thread t1 =  new Thread(futureTask1);
		Thread t2 =  new Thread(futureTask2);
        Thread t3 =  new Thread(futureTask3);


		t1.start();
		t2.start();	
        t3.start();
		
		try {
			//汇总
			int sum1 = futureTask1.get();
			int sum2 = futureTask2.get();
            int sum3 = futureTask3.get();
			int total = sum1+sum2+sum3;
			System.out.println("最终计算结果："+total);
		} catch (InterruptedException | ExecutionException e) {
			e.printStackTrace();
		}	
	}

}
class SumTask implements Callable<Integer>{
	private  int begin,end;
	public SumTask(int begin,int end) {
		this.begin = begin;
		this.end = end;
	}
	@Override
	public Integer call() throws Exception {
		int result = 0;
		for(int i = begin; i<=end; i++) {
			result += i;
		}
		return result;
	}
	
}

方式四: 通过线程池创建

第一步：使用Executors工具类创建出一个固定数量的线程池

第二步：使用ExecutorService接口来引用该线程池

第三步：调用ExecutorService.execute()方法，传入一个Runnable的接口的实现类

              或者调用ExecutorService.sumbit()方法，传入一个Callable接口的实现类

注意： 一般是通过new ThreadPoolExecutor（传入相应参数）来创建自定义线程池

           本文只是举例

public static void main(String[] args) {
	//固定数量的线程池
	ExecutorService service = Executors.newFixedThreadPool(5);
	while(true){
		service.execute(new Runnable() {
			@Override
			public void run() {
				System.out.println(Thread.currentThread().getName()+"创建一个商场");					
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}			
			}
		});
	}
}