线程实现接口方式（可以建立线程的接口）

网友投稿 347 2023-01-16


本篇文章给大家谈谈线程实现接口方式，以及可以建立线程的接口对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。 今天给各位分享线程实现接口方式的知识，其中也会对可以建立线程的接口进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

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

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

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;

}

}

多线程的几种实现方式

1、继承Thread类创建线程
Thread类本质上是实现了Runnable接口的一个实例，代表一个线程的实例。启动线程的唯一方法就是通过Thread类的start()实例方法。start()方法是一个native方法，它将启动一个新线程，并执行run()方法。这种方式实现多线程很简单，通过自己的类直接extend Thread，并复写run()方法，就可以启动新线程并执行自己定义的run()方法。例如：

public class MyThread extends Thread {  
public void run() {  
 System.out.println("MyThread.run()");  
}  
}  
 
MyThread myThread1 = new MyThread();  
MyThread myThread2 = new MyThread();  
myThread1.start();  
myThread2.start();

2、实现Runnable接口创建线程
如果自己的类已经extends另一个类，就无法直接extends Thread，此时，可以实现一个Runnable接口，如下：

public class MyThread extends OtherClass implements Runnable {  
public void run() {  
 System.out.println("MyThread.run()");  
}  
}

为了启动MyThread，需要首先实例化一个Thread，并传入自己的MyThread实例：

MyThread myThread = new MyThread();  
Thread thread = new Thread(myThread);  
thread.start();

事实上，当传入一个Runnable target参数给Thread后，Thread的run()方法就会调用target.run()，参考JDK源代码：

public void run() {  
if (target != null) {  
 target.run();  
}  
}

3、实现Callable接口通过FutureTask包装器来创建Thread线程

Callable接口（也只有一个方法）定义如下：

public interface Callable<V   { 
  V call（） throws Exception;   
 }
public class SomeCallable<V extends OtherClass implements Callable<V {
    @Override    public V call() throws Exception {        // TODO Auto-generated method stub
        return null;
    }
}
Callable<V oneCallable = new SomeCallable<V();   
//由Callable<Integer创建一个FutureTask<Integer对象：   
FutureTask<V oneTask = new FutureTask<V(oneCallable);   
//注释：FutureTask<Integer是一个包装器，它通过接受Callable<Integer来创建，它同时实现了Future和Runnable接口。 
  //由FutureTask<Integer创建一个Thread对象：   
  Thread oneThread = new Thread(oneTask);   
  oneThread.start();   
//至此，一个线程就创建完成了。

多线程有哪些实现方式?

java多线程的几种实现方式：
1.继承Thread类，重写run方法
2.实现Runnable接口，重写run方法，实现Runnable接口的实现类的实例对象作为Thread构造函数的target
3.通过Callable和FutureTask创建线程
4.通过线程池创建线程 （上一篇已经讲过了）
前面两种可以归结为一类：无返回值，原因很简单，通过重写run方法，run方式的返回值是void，所以没有办法返回结果
后面两种可以归结成一类：有返回值，通过Callable接口，就要实现call方法，这个方法的返回值是Object，所以返回的结果可以放在Object对象中

java有几种实现线程的方式

java创建线程的方式有三种
第一种是继承Thread类 实现方法run() 不可以抛异常 无返回值
第二种是实现Runnable接口 实现方法run() 不可以抛异常 无返回值
第三种是实现Callable<T接口,接口中要覆盖的方法是 public <T call() 注意:此方法可以抛异常,而前两种不能 而且此方法可以有返回值
第三种如何运行呢 Callable接口在util.concurrent包中,由线程池提交
import java.util.concurrent.*;
ExecutorService e = Executors.newFixedThreadPool(10); 参数表示最多可以运行几个线程
e.submit(); 这个里面参数传 实现Callable接口那个类的对象 关于线程实现接口方式和可以建立线程的接口的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。 线程实现接口方式的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于可以建立线程的接口、线程实现接口方式的信息别忘了在本站进行查找喔。

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。

标签：实现接口 接口 代码 对象 方法
上一篇:Java异常处理之try...catch...finally详解
下一篇:Java集合总结
相关文章

 发表评论

暂时没有评论，来抢沙发吧~