多线程有三种常见的实现方式：
1. 继承Thread类,重写run方法。
2. 实现Runnable接口,重写run方法。
3. 通过实现Callable接口和使用FutureTask包装器来实现线程
/**
* 通过自己的类直接继承(extend) Thread，并复重写run()方法，就可以通过Thread类的start()方法启动线程，并执行自己定义的run()方法。Thread类的start()方法是启动线程的唯一方法。
* @author Lucky
*/
public class myThread_1 extends Thread{
public void run(){
System.out.println("方法1:继承Thread类,重写run方法");
}
public static void main(String args[]){
myThread_1 m1=new myThread_1();
myThread_1 m2=new myThread_1();
m1.start();
m2.start();
}
}
/**
* 通过实现Runnable接口,重写run方法，将接口的实现类的实例作为参数传入带参的Thread构造函数中，然后就可以通过调用Thread类的start()方法启动线程。
* @author Lucky
* */
class myt2 implements Runnable{
public void run(){
System.out.println("方法2:通过实现Runnable接口,重写run方法");
}
}
public class myThread_2{
public static void main(String args[]){
//为了启动MyThread_2，
//创建一个Runnable子类的对象，然后把这个对象当作参数传入Thread实例中，
//这样就可以调用start()方法启动线程了。
//start()是Thread类中的方法。
myt2 m=new myt2();
Thread t1= new Thread(m);
t1.start();
}
}
/**通过Callable和FutureTask创建线程 。 创建Callable接口的实现类 ，并实现Call方法 ;
* 由Callable<Object>创建一个FutureTask<Object>对象;
* FutureTask<Object>是一个包装器，它通过接受Callable<Object>来创建;
* 由FutureTask<Object>创建一个Thread对象;
* 最后通过调用Thread类的start()方法启动线程。
* @author Lucky
*/
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
public class myThread_3 {
public static void main(String args[]){
Callable<Object> c=new myt3<Object>();
FutureTask<Object> f=new FutureTask<Object>(c);
Thread t=new Thread(f);
t.start();
}
}
//创建Callable接口的实现类，并重写call()方法
@SuppressWarnings("hiding")
class myt3<Object> implements Callable<Object>{
//重写call()方法
public Object call() throws Exception{
System.out.println("方法3:通过实现Callable接口和使用FutureTask包装器来实现线程");
return null;
}
}
网友评论