多线程的三种使用方法

（初学java，个人见解，不一定正确）
第一种

package Thread;
//创建线程的第一种方法，继承Thread，重写run方法
public class ThreadOne extends Thread{

@Override
public void run(){//虚拟机执行此线程时调用，方法中放要处理任务（要执行的代码）
	System.out.println("线程抢到CPU资源，开始执行，做某一项任务");
	System.out.println(Thread.currentThread().getPriority());
	System.out.println(Thread.currentThread().getState());//输出当前线程的状态
	//Thread.currentThread()获得当前正在执行的线程，getState()获得线程的状态
	for (int i = 0; i < 10; i++) {
		try {
			Thread.sleep(2000);//让当前线程休眠多长时间，毫秒；让出2000毫秒的时间不去跟别人抢，休眠结束后继续抢CPU
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread().getName()+"循环下标："+i);
	}
}
public static void main(String[] args) throws InterruptedException {
	//main方法是java程序的入口，main方法会启动一个主线程
	System.out.println(Thread.currentThread().getName());
	Thread.currentThread().setPriority(10);//设置线程优先级
	
	ThreadOne one=new ThreadOne();//创建线程对象
	one.setName("线程1");//给线程设置名字
	System.out.println("线程1创建完成，还未start");
	
	one.start();//启动线程，并不一定立马执行run，只有当此线程抢到CPU资源的时候才能执行
	//开始跟上面main线程抢CPU资源，谁抢到资源，谁就执行
	
	for (int i = 0; i < 10; i++) {//main线程中要输出10次循环
		Thread.sleep(1000);//让main线程休眠1秒，不跟别的 线程抢资源
		System.out.println(Thread.currentThread().getName()+i);
	}
	
	System.out.println(one.getState());
	Thread.currentThread().sleep(500);
	
	one.stop();
	System.out.println(one.getState());
	
	System.out.println(Thread.currentThread().getName()+"优先级："+Thread.currentThread().getPriority());
	/*System.out.println();*/
  }
}

第二种

package Thread;
//创建线程的第二种方法，实现Runnable接口，重写run方法
public class ThreadTwo implements Runnable{
private String name="abc";

@Override
public void run() {//虚拟机执行此线程时调用，方法中放要处理任务（要执行的代码）
	// TODO Auto-generated method stub
	System.out.println("线程执行，做某一项任务");
	for (int i = 0; i < 10; i++) {
		try {
			Thread.sleep(500);//让前线程休眠多长时间，毫秒；让出500毫秒的时间不去跟别人抢，休眠结束后继续抢CPU
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}//Thread.currentThread()获取当前正在执行的线程
		System.out.println(Thread.currentThread().getName()+"循环下标："+i);
	}
}

public static void main(String[] args) {
	ThreadTwo th=new ThreadTwo();//Runnable接口实现类的实例
	
	Thread a=new Thread(th,"线程A");//灵活
	Thread b=new Thread(th,"线程B");
	Thread c=new Thread(th,"线程C");
	Thread d=new Thread(th,"线程D");
	
	a.start();
	b.start();
	c.start();
	d.start();
}

}

第三种

package Thread;

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
/**
* 创建线程的第三种方式：
* Runnable run方法无返回值，不能直接获得线程执行的结果，不能抛异常
* 
* 1.定义一个线程任务类实现Collable接口，申明线程执行的结果类型
* 2.重写线程任务类的call方法，这个方法可以直接返回执行的结果
* 3.创建一个Callable线程任务对象
* 4.把Callable的线程任务对象包装成一个未来任务对象
* 5.把未来任务对象包装成线程对象，调用线程的start方法启动线程
* 6.通过FutureTask对象的get方法取线程执行结果后的返回结果
* 
* 优点：
* 可以继承其他的类，同时可以继承实现其他接口
* 一个线程任务对象可以被共享成多个线程对象，适合做多线程的资源共享操作
* 很适合做线程池的执行任务，可以获得线程执行的结果
* 缺点：
* 编程复杂
*/
//public class ThreadThree implements Runnable{
public class ThreadThree implements Callable<String>{//1.定义一个线程任务类实现Collable接口，申明线程执行的结果类型

@Override
public String call() throws Exception {//2.重写线程任务类的call方法，这个方法可以直接返回执行的结果
	// TODO Auto-generated method stub
	int sum = 0;
	for (int i = 0; i < 10; i++) {
		System.out.println(Thread.currentThread().getName()+":"+i);
		sum+=i;//55
	}
	return "Callable的call方法返回值为："+String.valueOf(sum);
}

public static void main(String[] args) {
	Callable call = new ThreadThree();// 3.创建一个Callable线程任务对象
	
	//把callable对象包装成未来任务对象，是一个runnable对象，可以在线程执行完成后获取线程执行结果
	FutureTask<String> task_Runnable = new FutureTask<String>(call);//4.把Callable的线程任务对象包装成一个未来任务对象
	
	//重点：不管是第一，第二种，还是第三种方式创建线程，都离不开Thread类！线程都是一个Thread对象
	Thread thread = new Thread(task_Runnable,"线程3");//5.把未来任务对象包装成线程对象
	
	thread.start();//5.调用线程的start方法启动线程
	
	//在最后获取线程执行结果，如果线程没有结果，会让出CPU等线程执行完，再来取结果
	try {
		//6.通过FutureTask对象的get方法取线程执行结果后的返回结果
		String s = task_Runnable.get();//获取call方法返回的结果（正常/异常结果）
		System.out.println(s);
	} catch (Exception e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
}
}