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实现有返回结果的多线程。（有返回值）。
