一.多线程实现方式二：
1.目标：
/* 多线程实现方式二：实现Runnable接口
1.定义一个线程任务类MyRunnable实现Runnable接口，重写run方法；
2.创建MyRunnable任务对象
3.把MyRunnable任务对象交给Thread处理
4.调用线程对象start()方法启动线程；
*/2.代码展示：
public class RunnableDemo {
public static void main(String[] args) {
//2.创建MyRunnable任务对象
Runnable target=new MyRunnable();
//3.把MyRunnable任务对象交给Thread处理
Thread t=new Thread(target);
//4.调用线程对象start()方法启动线程
t.start();
for (int i = 0; i < 5; i++) {
System.out.println("主线程执行调用: "+i);
}
}
}
//1.定义一个线程任务类MyRunnable实现Runnable接口，重写run方法；
class MyRunnable implements Runnable{
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println("子线程执行调用："+i);
}
}
}3.优缺点：
优点：线程任务类只是实现接口，还可以继续继承和实现接口，扩展性强。
缺点：编程多一层对象包装，如果线程有执行结果是不可以直接返回的。
4.语法形式：匿名内部类
//线程的创建方式二： 匿名内部类，（语法形式）
public class RunnableDemoOther {
public static void main(String[] args) {
//2.创建一个任务对象
Runnable target=new Runnable() {
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println("子线程执行调用: "+i);
}
}
};
//3.把MyRunnable任务对象交给Thread处理
Thread t=new Thread(r);
//4.调用线程对象start()方法启动线程
t.start();
for (int i = 0; i < 5; i++) {
System.out.println("主线程执行调用: "+i);
}
}
}二.多线程实现方式三：
1.针对于前两种继承Thread类和实现Runnable接口，都存在共性问题？
1.两者重写Run方法都不能直接返回结果；
2不适合需要返回执行结果的业务场景；
2.怎么解决呢？
我们接下来开始学习多线程实现方式三： JDK 5.0 提供实现Callable和FutureTask接口来实现，解决可以直接返回结果的业务。
3.需求分析
/*多线程实现方案三：利用callable和futureTask接口实现
1，创建任务类，实现callable接口，重新call方法，封住要做的事情
2.用futureTask把callable对象封装成线程任务对象
3.把线程任务交给Thread处理
4.调用Thread的start方法启动线程，执行任务
5.执行完毕，通过futureTask的get方法获取任务执行的结果
*/4.代码实现：
//1.定义一个任务类实现callable接口重写call方法 声明程序执行结果的类型String
class MyCallable implements Callable<String> {
private int n;
public MyCallable(int n) {
this.n = n;
}
//2.线程的任务方法；计算1到100/200的和
@Override
public String call() throws Exception {
int sum = 0;
for (int i = 0; i <= n; i++) {
sum += i;
}
System.out.println(Thread.currentThread().getName());
return "子线程的执行结果是:" + sum;
}
}public class CallableDemo {
public static void main(String[] args) {
//创建callable任务对象
Callable<String> call = new MyCallable(100);
//futureTask对象作用1：是Runnable的对象（实现Runnable接口），交给Thread
//futureTask对象作用2: 可以在线程执行完毕之后通过调用get方法得到线程执行之后的结果：
FutureTask<String> f1 = new FutureTask<>(call);
//交给线程处理
Thread t1 = new Thread(f1);
//启动线程
t1.start();
Callable<String> call2 = new MyCallable(200);
FutureTask<String> f2 = new FutureTask<>(call2);
Thread t2 = new Thread(f2);
t2.start();
try {
String s1 = f1.get();
System.out.println("第一个结果："+s1);
} catch (Exception e) {
e.printStackTrace();
}
try {
String s2 = f2.get();
System.out.println("第二个结果："+s2);
} catch (Exception e) {
e.printStackTrace();
}
}
}优缺点：
1.优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强；
可以在线程执行完毕之后get执行结果；
缺点：代码复杂一点；
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
