多线程实现的四种方式(实现多线程的三种方法)
各位老铁们好，相信很多人对多线程实现的四种方式都不是特别的了解，因此呢，今天就来为大家分享下关于多线程实现的四种方式以及实现多线程的三种方法的问题知识，还望可以帮助大家，解决大家的一些困惑，下面一起来看看吧！
多线程的三种常见实现方式
多线程有三种常见的实现方式：
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对象中
JAVA多线程有哪几种实现方式
JAVA多线程实现方式主要有三种：继承Thread类、实现Runnable接口、使用ExecutorService、Callable、Future实现有返回结果的多线程。其中前两种方式线程执行完后都没有返回值，只有最后一种是带返回值的。
1、继承Thread类实现多线程
继承Thread类的方法尽管被我列为一种多线程实现方式，但Thread本质上也是实现了Runnable接口的一个实例，它代表一个线程的实例，并且，启动线程的唯一方法就是通过Thread类的start()实例方法。start()方法是一个native方法，它将启动一个新线程，并执行run()方法。这种方式实现多线程很简单，通过自己的类直接extend Thread，并复写run()方法，就可以启动新线程并执行自己定义的run()方法。例如：
[java]view plaincopy
publicclassMyThreadextendsThread{
publicvoidrun(){
System.out.println("MyThread.run()");
}
}
在合适的地方启动线程如下：
[java]view plaincopy
MyThreadmyThread1=newMyThread();
MyThreadmyThread2=newMyThread();
myThread1.start();
myThread2.start();
2、实现Runnable接口方式实现多线程
如果自己的类已经extends另一个类，就无法直接extends Thread，此时，必须实现一个Runnable接口，如下：
[java]view plaincopy
publicclassMyThreadextendsOtherClassimplementsRunnable{
publicvoidrun(){
System.out.println("MyThread.run()");
}
}
为了启动MyThread，需要首先实例化一个Thread，并传入自己的MyThread实例：
[java]view plaincopy
MyThreadmyThread=newMyThread();
Threadthread=newThread(myThread);
thread.start();
事实上，当传入一个Runnable target参数给Thread后，Thread的run()方法就会调用target.run()，参考JDK源代码：
[java]view plaincopy
publicvoidrun(){
if(target!=null){
target.run();
}
}
3、使用ExecutorService、Callable、Future实现有返回结果的多线程
ExecutorService、Callable、Future这个对象实际上都是属于Executor框架中的功能类。想要详细了解Executor框架的可以访问，这里面对该框架做了很详细的解释。返回结果的线程是在JDK1.5中引入的新特征，确实很实用，有了这种特征我就不需要再为了得到返回值而大费周折了，而且即便实现了也可能漏洞百出。
可返回值的任务必须实现Callable接口，类似的，无返回值的任务必须Runnable接口。执行Callable任务后，可以获取一个Future的对象，在该对象上调用get就可以获取到Callable任务返回的Object了，再结合线程池接口ExecutorService就可以实现传说中有返回结果的多线程了。下面提供了一个完整的有返回结果的多线程测试例子，在JDK1.5下验证过没问题可以直接使用。
如果你还想了解更多这方面的信息，记得收藏关注本站。