创建线程的3种方式

一、继承Thread类创建线程类

（1）定义Thread类的子类，并重写该类的run方法，该run方法的方法体就代表了线程要完成的任务。
     因此把run()方法称为执行体。
（2）创建Thread子类的实例，即创建了线程对象。
（3）调用线程对象的start()方法来启动该线程。

public class MyThread extends Thread{
 	 @Override
	public void run() {
		// TODO Auto-generated method stub
		//super.run();
		 doSomething();
	}
 
	private void doSomething() {
		// TODO Auto-generated method stub
		System.out.println("我是一个线程中的方法");
        System.out.println("我是一个线程中的方法");
        System.out.println("我是一个线程中的方法");
	}
}

public class NewThread {
	public static void main(String[] args) {
		MyThread myThread=new MyThread();
		myThread.start();//开启一个线程方法
	    //以下的方法可与上边的线程并发执行
		doSomething();
        doSomething();
        doSomething();
	}
 
	private static void doSomething() {
		// TODO Auto-generated method stub
        System.out.println("NewThread++++++++一个线程中的");
	}
 
}

 

我是一个线程中的方法
我是一个线程中的方法
我是一个线程中的方法
NewThread++++++++一个线程中的
NewThread++++++++一个线程中的
NewThread++++++++一个线程中的

 在main()方法里创建一个MyThread对象，调用该对象的start()方法，start()方法会通过对系统底层的一系列操作，创建出一个相应的线程，与当前线程并发执行。如果直接调用run()方法，程序将执行完run()方法后才会执行main()方法中后面的代码,这样就是单线程执行而不是多线程并发执行了。
 

二、通过Runnable接口创建线程类

（1）定义runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体
    同样是该线程的线程执行体。
（2）创建 Runnable实现类的实例，并依此实例作为Thread的target来创建Thread对象，
     该Thread对象才是真正的线程对象。（不同的是，实现Runnable接口的类中没有
     start()方法，所以要用Thread构造个方法开启线程）
（3）调用线程对象的start()方法来启动该线程。

public class RunnableThread implements Runnable {
    @Override
    public void run() {
        doSomeThing();
    }
    private void doSomeThing() {
        System.out.println("我是一个线程方法");
    }
}

public class RunnableNewThread {
    public static void main(String[] args) {
        Runnable runnable=new RunnableThread();
        Thread thread=new Thread(runnable);
        thread.start();//开启一个线程方法
        //以下的方法可与上边的线程并发执行
        doLineSomething();
    }
    private static void doLineSomething() {
    }
}

 三、通过Callable和Future创建线程

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

public class CallableThread implements Callable<String>{
 
	@Override
	public String call() throws Exception {
		// TODO Auto-generated method stub
		doSomeThing();
		return "需要返回的值";
	}
 
	private void doSomeThing() {
		System.out.println("我是线程中的方法");
	}
 
}

public class NewThread {
	public static void main(String[] args) {
		Callable<String> callable=new CallableThread();
		FutureTask<String> futureTask=new FutureTask<String>(callable);
		Thread thread=new Thread(futureTask);
		thread.start();//开启一个线程方法
	    //以下的方法可与上边的线程并发执行
		doNewSomething();
		try {
			futureTask.get();//获取线程返回值
		} catch (InterruptedException | ExecutionException e) {
			e.printStackTrace();
		}
	}
 
 	private static void doNewSomething() {
	}
}

首先创建Callable接口的实现类CallableThread，实现call()方法，并且有返回值。
Callable接口是一个带泛型的接口，泛型的类型就是线程返回值的类型。
实现Callable接口中的call()方法，方法的返回类型与泛型的类型相同。
Callable不能直接获取返回值，需要用FutureTask<V>在外部封装一下再获取返回值

四：创建线程的三种方式的对比

采用实现Runnable、Callable接口的方式创见多线程时，优势是：
   线程类只是实现了Runnable接口或Callable接口，还可以继承其他类。
   在这种方式下，多个线程可以共享同一个target对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将CPU、代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想。

劣势是：
   编程稍微复杂，如果要访问当前线程，则必须使用Thread.currentThread()方法。


使用继承Thread类的方式创建多线程时优势是：
   编写简单，如果需要访问当前线程，则无需使用Thread.currentThread()方法，直接使用this即可获得当前线程。

劣势是：
   线程类已经继承了Thread类，所以不能再继承其他父类。