线程的实现方式

方式一：继承  java.lang.Thread 类（线程子类）

继承Thread类，然后重写run()方法。

//线程创建方式1：继承Thread类
public class Demo02 {
	public static void main(String[] args) {
		SubThread t1=new SubThread("线程甲");
		SubThread t2=new SubThread("线程乙");
		SubThread t3=new SubThread("线程丙");
		t1.start();
		t2.start();
		t3.start();
	}

}

//继承Thread,重写run()方法
class SubThread extends Thread{
	public SubThread(String name) {
		super(name);
	}
	@Override
	public void run() {
		for(char c='A';c<='Z';c++) {
			System.out.printf("[%s]:%s\n",this.getName(),c);
		}
	}
}

方式二：实现  java.lang.Runnable 接口（线程执行类）

实现 Runnable接口，重写run()方法，Runnable接口的实现类封装了线程执行逻辑，最后调用start()方法启动线程。

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

}
//子类（邮件任务）
class EmailTask extends Task implements Runnable{

	@Override
	public void run() {
		execute();
		
	}

	@Override
	public void execute() {
		//获取当前线程对象
		Thread currentThread=Thread.currentThread();
		//获取线程名称
		String threadName=currentThread.getName();
		System.out.println(threadName+":使用JavaMail技术，通过SMTP协议发送邮件");
		
	}
	
}
//父类（任务）
abstract class Task{
	public abstract void execute();
}

 

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

实现Callable接口，Callable接口的实现类中封装了某个数据范围内的累加和的逻辑，实例化SumCalcTask实现类，创建不同数据范围的计算任务，将线程任务封装为FutureTask<E>（Runnable接口实现类）对象，最后创建并启动线程。

//线程创建方式3:实现Callable接口
public class Demo04 {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		//Callable接口实现类：不同数据范围的计算任务
		SumCalcTask task1=new SumCalcTask(1, 300);
		SumCalcTask task2=new SumCalcTask(301, 500);
		SumCalcTask task3=new SumCalcTask(501, 1000);
		//Callable--->FutureTask(Runnable接口实现类)
		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);
		//线程启动
		//futureTask1.run();----->
		//callable.call();--->结果---->outcome
		t1.start();
		t2.start();
		t3.start();
		//线程执行结束，分别获取各自线程的返回结果
		System.out.println("开始分别获取.........");
		Integer sum1=futureTask1.get();
		Integer sum2=futureTask2.get();
		Integer sum3=futureTask3.get();
		//汇总
		System.out.println("汇总各自计算结果：");
		Integer sum=sum1+sum2+sum3;
		System.out.println("最终计算结果："+sum);
		
		
	}

}
//通过Callable接口实现类SumCalcTask封装某个范围内数据的累加和
class SumCalcTask implements Callable<Integer>{
	private int begin,end;
	public SumCalcTask(int begin,int end) {
		this.begin=begin;
		this.end=end;
	}
	@Override
	public Integer call() throws Exception {
		int total=0;
		for(int i=begin;i<=end;i++) {
			total+=i;
		}
		System.out.println(Thread.currentThread().getName()+"结束执行");
		return total;
	}
	
}

 

方式四：线程池

线程池，按照配置参数（核心线程数、最大线程数等）创建并管理若干线程对象。程序中如果需要使用线程，将一个执行任务传给线程池，线程池就会使用一个空闲状态的线程来执行这个任务。执行结束以后，该线程并不会死亡，而是再次返回线程池中成为空闲状态，等待执行下一个任务。使用线程池可以很好地提高性能。

使用ExecutorService threadPool=Executors.newFixedThreadPool(10)创建固定数量的线程池，调用ExecutorService的execute()方法，向线程池提交一个执行任务（传入Runnable接口的实现类对象）或者调用ExecutorService的submit()方法，向线程池提交一个执行任务（传入Callable接口的实现类对象），然后线程池分配一个空闲线程执行该任务，如果没有空闲线程，则该任务进入等待序列。

//线程的创建方式4：通过线程池创建
public class Demo05 {
	public static void main(String[] args) {
		//固定数量（10）的线程池
			ExecutorService threadPool=Executors.newFixedThreadPool(10);
			//不确定数量的线程请求
			while(true) {
				//向线程池提交一个执行任务（Runnable接口实现类对象）
				//线程池分配一个“空闲线程”执行该任务
				//如果没有空闲线程，则该任务进入“等待序列（工作序列）”
				threadPool.execute(new Runnable() {
					@Override
					public void run() {
						System.out.println(Thread.currentThread().getName());
						try {
							Thread.sleep(1000);//当前线程休眠1000毫秒
						} catch (InterruptedException e) {
							e.printStackTrace();
						}
					}
				});
			}
	}

}

 

//线程池执行Callable接口封装的线程任务
public class Demo06 {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		//Callable接口实现类：不同数据范围的计算任务
		SumCalcTask task1=new SumCalcTask(1, 300);
		SumCalcTask task2=new SumCalcTask(301, 500);
		SumCalcTask task3=new SumCalcTask(501, 1000);
		//线程池
		ExecutorService executorService=Executors.newFixedThreadPool(3);
		//提交Callable接口封装的线程任务
		Future<Integer> f1=executorService.submit(task1);
		Future<Integer> f2=executorService.submit(task2);
		Future<Integer> f3=executorService.submit(task3);
		//分别获取各自计算结果
		int r1=f1.get();
		int r2=f2.get();
		int r3=f3.get();
		int ret=r1+r2+r3;
		System.out.println(ret);
		executorService.shutdownNow();
	}

}