多线程的三种常见实现方式

多线程有三种常见的实现方式：

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

}

}

java多线程的几种实现方式：闭耐困

1.继承Thread类，重写run方法

2.实现Runnable接口，重写轿念run方法，实现Runnable接口的实现类的实例对象作为Thread构造函数的target

3.通过Callable和FutureTask创建线程

4.通过线程池创建线程 （上一篇已经讲过了）

前面两种可以归结为一类：无返回值，原因很简单，通过重写run方法，run方式的返亩判回值是void，所以没有办法返回结果

后面两种可以归结成一类：有返回值，通过Callable接口，就要实现call方法，这个方法的返回值是Object，所以返回的结果可以放在Object对象中

---