实现线程的几种方式

Java使用Thread类代表线程,所有的线程对象都必须是Thread类或其子类的实例。
Java可以用三种方式来创建线程，如下所示：

1、通过继承Thread类创建线程

/**
 * (1).首先定义一个类去继承Thread父类，重写父类中的run()方法。在run()方法中加入具体的任务代码或处理逻辑。
 * (2).直接创建一个ThreadTest类的对象，也可以利用多态性，变量声明为父类的类型。
 * (3).调用start方法，线程启动，隐含的调用run()方法。
 */
public class ThreadTest extends Thread{  

	public void run(){  
		while (true) {
			try {
				Thread.sleep(1000);//休眠1000毫秒(就是1秒)
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("打印当前线程名称: "+Thread.currentThread().getName());
			
			//打印当前线程名称,这里采用this来获取,在某些时候这里并不适用,推荐使用上面一种方式
			System.out.println("通过this调用getName方法,打印线程名称: "+this.getName());
		}         
    }  
     
    //在main方法中演示调用
    public static void main(String[] args) {  
        ThreadTest thread1=new ThreadTest();//创建第一个线程对象  
        thread1.start(); //启动第一个线程
        
        ThreadTest thread2=new ThreadTest();//创建第二个线程对象
        thread2.start(); //启动第二个线程 
    }  
}  

2、通过实现Runnable接口创建线程

/**
 * (1).定义一个类实现Runnable接口，重写接口中的run()方法。在run()方法中加入具体的任务代码或处理逻辑。
 * (2).创建Runnable接口实现类的对象。
 * (3).创建一个ThreadTest类的对象，需要封装前面Runnable接口实现类的对象。（接口可以实现多继承）
 * (4).调用Thread对象的start()方法，启动线程
 */

public class ThreadTest implements Runnable{  
      
    @Override  
    public void run() {  
    	while (true) {
			try {
				Thread.sleep(1000);//休眠1000毫秒(就是1秒)
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("打印当前线程名称: "+Thread.currentThread().getName());
		}  
    }  
    
    //在main方法中演示调用
    public static void main(String[] args) {  
        Thread theard=new Thread(new ThreadTest()); //创建线程对象
        theard.start();  //启动线程
    }  
}  

3.通过Callable和Future创建线程

/**
 * （1）创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，并且有返回值。
 * （2）创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。
 * （3）使用FutureTask对象作为Thread对象的target创建并启动新线程。
 * （4）调用FutureTask对象的get()方法来获得子线程执行结束后的返回值
 */
 
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
public class ThreadTest implements Callable<Integer>{  
  
    @Override  
    public Integer call() throws Exception {  
        int count =0;  
        for(int i=0;i<=10;i++){  
            count=count+i;  
        }  
      System.out.println("打印当前线程名称: "+Thread.currentThread().getName());
      return count; //返回值     
    }  
    
    //在main方法中演示调用
    public static void main(String[] args) throws Exception {  
        FutureTask<Integer> thread = new FutureTask<>(new ThreadTest());  
        new Thread(thread,"这是线程名称").start(); //启动线程   
        System.out.println(thread.get()); //打印线程返回值 
    }  
      
}  

总结如下

采用继承Thread类方式：
（1）优点：编写简单，如果需要访问当前线程，无需使用Thread.currentThread()方法，直接使用this，即可获得当前线程。
（2）缺点：因为线程类已经继承了Thread类，所以不能再继承其他的父类。

采用实现Runnable接口方式：
（1）优点：线程类只是实现了Runable接口，还可以继承其他的类。在这种方式下，
		 可以多个线程共享同一个目标对象，所以非常适合多个相同线程来处理同一份资源的情况，
		 从而可以将CPU代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想。
（2）缺点：编程稍微复杂，如果需要访问当前线程，必须使用Thread.currentThread()方法。

下面我直接再将三种实现方式写在一起贴下，代码如下：

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

public class ThreadDemo {
	
	public static void main(String[] args) {
		
		// =======  创建线程方式一  开始 (Thread是一个类继承了Runnable接口) =======
		Thread thread = new Thread(){
			@Override
			public void run() {//该方法中写我们业务代码
				
				while (true) {
					try {
						Thread.sleep(1000);//休眠1000毫秒(就是1秒)
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					//打印当前线程名称
					System.out.println("创建线程方式一,打印线程名称: "+Thread.currentThread().getName());
					
					//打印当前线程名称,这里采用this来获取,在某些时候这里并不适用,推荐使用上面一种方式
					System.out.println("创建线程方式一,通过this调用getName方法,打印线程名称: "+this.getName());
				}
			}
		};
		
		thread.start();//启动线程
		// =======  创建线程方式一  结束  =======
		
		
		// =======  创建线程方式二开始  (Runnable是一个接口)=======
		Thread thread2 = new Thread(new Runnable() {

			@Override
			public void run() {//该方法中写我们业务代码
				while (true) {
					try {
						Thread.sleep(1000);//休眠1000毫秒(就是1秒)
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					//打印当前线程名称
					System.out.println("创建线程方式二,打印线程名称: "+Thread.currentThread().getName());
					
					//TODO 这种方式就不适合上面打印2的方式通过this来调用获取当前线程名称的方法
				}
				
			}
		});
		
		thread2.start();//启动线程
		// =======  创建线程方式二  结束  =======
		
		
		// =======  创建线程方式三 开始  =======
        FutureTask<Integer> thread3 = new FutureTask<>(new Callable<Integer>() {

			@Override
			public Integer call() throws Exception {
				int count =0;  
		        for(int i=0;i<=10;i++){  
		            count=count+i;  
		        }  
		        //打印当前线程名称
				System.out.println("创建线程方式三,打印线程名称: "+Thread.currentThread().getName());
		        return count; //返回值   
			}
		});  
        
        new Thread(thread3,"这是线程名称").start();//启动线程
        try {
			System.out.println("创建线程方式三,打印返回值:"+ thread3.get());//打印返回值
		} catch (Exception e) {
			e.printStackTrace();
		} 
     // =======  创建线程方式三 结束  =======
		
	}

}