JAVA代码实现多线程的方式总结
1) 第一种方式：
a. 类 继承 java.lang.Thread类，同时覆盖run方法
注意：线程任务定义在run方法中
b. 创建线程对象：
MyThread t = new MyThread();
c. 开启线程：利用 start开启线程，jvm执行线程时会自动的
调用run
main（）//略
// 创建线程对象
MyThread t = new MyThread();
// 开启线程
t.start();
// t.run();//只是普通方法的调用，不是开启线程
for(int i=1;i<=200;i++) {
System.out.println("++++++++++++++"+i);
}
System.out.println("--------main ----
end----2");
}
public static void m1() {}
}
// 线程的任务：打印输出 20行 "--------------------
--"
class MyThread extends Thread{
// 线程任务：定义在 run方法中
public void run() {
for(int i=1;i<=20;i++) {
System.out.println("---------------
--"+i);//3
}
System.out.println("哈哈哈......run方
法.");
test();
}
public void test() {
System.out.println("test被调用......");
}
}
2) 第二种方式：
a. 类 实现 java.lang.Runnable接口，实现接口中run方法
注意：实现run时，访问修饰符必须是 public
任务代码定义在run方法中
当前类代表是任务类
b. 创建目标对象：MyTarget tg = new MyTarget();
c. 创建线程对象，同时将目标对象作为参数进行传递
Thread t = new Thread(tg);
d. 开启线程：调用 start方法
t.start();// jvm默认调用run方法
public class TestRunnable {
public static void main(String[] args) {
System.out.println("main---start-------
---");
// 创建目标对象
Runnable tg = new MyTarget();// 多态：接
口类型指向实现类对象
// 创建线程对象
Thread t = new Thread(tg);
// 开启线程
t.start();
for(int i=0;i<=200;i++) {
System.out.println("~~~~~~~~~~~~~~~~~~~"+i);
}
System.out.println("-----main----end---
----");
}
}
// 任务：打印 20行"*************************"
class MyTarget implements Runnable{
public void run() {
for(int i=1;i<=20;i++) {
System.out.println("***************"+i);
}
}
}
3)第三种： 线程池
① 线程池：线程容器，将预先创建的线程对象存入到线程池
中，只要将任务提交给线程池，会分配对象线程对象完成提交
任务，线程池中的线程对象可以被重复使用。
② 好处：避免频繁的创建线程和销毁，从而提高空间利用和执
行效率。
③ 线程池常用的接口和类：(位于 java.util.concurrent包中)
a. Executor：线程池的顶级接口
b. ExecutorService：是 Executor的子接口，线程池的核心接口
I. submit(Runnable task)：将线程任务提交给线程池
submit(Callable<\T> task)：将线程任务提交给线程池
II. shutdown():关闭线程池，将线程池的线程对象全部销毁。
c. Executors：获取线程池对象的工具类，其中方法基本都为静
态方法。
I. static ExecutorService newFixedThreadPool(int n):获取一
个固定数
量线程的线程池，参数指定线程池中线程对象的数量
II. static ExecutorService newCachedThreadPool()：获取动
态数量线程对象的线程池，根据提交的任务需求，不够用时，
则自动完成线程创建。
public class TestThreadPool {
public static void main(String[] args) {
// 获取 线程池对象
ExecutorService pool =
Executors.newFixedThreadPool(2);
// 将线程任务(Runnable类型任务)提交给线程池
Runnable r1 = new Runnable() {
public void run() {
for(int i=1;i<=20;i++) {
System.out.println("---------
"+i);
}
}
};
pool.submit(r1);// 提交任务
pool.shutdown();
}
}
4) 第四种方式：Callable
a. Callable接口：位于 java.util.concurrent 包中，类似于
Runnable接口的应用，对应的对象代表线程任务。注意：
Callable是泛型接口，泛型约束了接口中方法的返回值的数据类
型
b. 接口中的方法： V call()：带有返回值的方法，同时可以抛出
异常
Future< T> f= pool.submit(c1);
c. Future是存储submit提交任务执行之后的结果
利用 Future中的 get方法获取执行的结果。
public class TestCallable {
public static void main(String[] args)throws
Exception{
ExecutorService pool =
Executors.newFixedThreadPool(2);
// 1+2+.....+100
// 任务1： 1+2+.....+50
Callable<Integer> c1 = new
Callable<Integer>() {
public Integer call() {
int sum1=0;
for(int i=1;i<=50;i++) {
sum1 +=i;
}
System.out.println("sum1="+sum1);
return sum1;
}
};
// 任务2:51+52+....100
Callable<Integer> c2 = new
Callable<Integer>() {
public Integer call() {
Integer sum2 = 0;
for(int i=51;i<=100;i++) {
sum2 +=i;
}
System.out.println("sum2="+sum2);
return sum2;
}
};
// 从线程1和线程2中分别获取结果，总结果汇总
Future<Integer> f1 = pool.submit(c1);
Future<Integer> f2 = pool.submit(c2);
Integer r1 = f1.get();
Integer r2 = f2.get();
System.out.println(r1+r2);
}
}
总结：
1.继承Thread类（无返回值）。
2.实现Runnable接口（无返回值）。
3.实现Callable接口，通过FutureTask包装器来创建Threak线程（有返回值）。
4.使用ExecutorService，Callable,Future实现有返回结果的多线程。（有返回值）。
