多线程的四种实现方式

 1 // 1、 创建一个继承于Thread类的子类
 2 class Test1 extends Thread {
 3 
 4     // 2、 重写Thread类的run()
 5     @Override
 6     public void run() {
 7         //Thread.currentThread().getName()：获取当前线程的名字
 8         System.out.println("线程需要执行的代码" + "->"
 9                 + Thread.currentThread().getName());
10     }
11 
12 }
13 
14 public class ThreadTest1 {
15     public static void main(String[] args) {
16         // 3、 创建Thread类的子类的对象
17         Test1 test1 = new Test1();
18         
19         //多线程当然可以创建多个对象来开启多个线程
20         Test1 test2 = new Test1();
21         
22         // 4、通过此对象调用start()方法启动线程
23         //start()方法的作用：1）启动当前线程  2）调用当前线程的run()方法
24         test1.start();
25         test2.start();
26     }
27 }

 1 //1. 创建一个实现Runnable接口的类
 2 class Test2 implements Runnable {
 3     // 2. 实现Runnable中的run()方法
 4     @Override
 5     public void run() {
 6         System.out.println("线程需要执行的代码" + "->"
 7                 + Thread.currentThread().getName());
 8     }
 9 }
10 
11 public class ThreadTest2 {
12     public static void main(String[] args) {
13         // 3. 创建实现类的对象
14         Test2 test = new Test2();
15         // 4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
16         Thread t1 = new Thread(test);
17         Thread t2 = new Thread(test);
18         // 5. 通过Thread类的对象调用start()
19         t1.start();
20         t2.start();
21 
22     }
23 }

 1 import java.util.concurrent.Callable;
 2 import java.util.concurrent.ExecutionException;
 3 import java.util.concurrent.FutureTask;
 4 
 5 //1.创建Callable的实现类
 6 class Test3 implements Callable<Object>{
 7   //2.实现call方法，将此线程需要执行的操作声明在call()中
 8   @Override
 9   public Object call() throws Exception {
10       int sum = 0;
11       for (int i = 1; i <= 100; i++) {
12           if(i % 2 == 0){
13               System.out.println(i);
14               sum += i;
15           }
16       }
17       return sum;
18       //如果不需要方法返回值
19       //return null;
20   }
21 }
22 
23 
24 public class ThreadTest3 {
25   public static void main(String[] args) {
26       //3.创建Callable接口实现类的对象
27       Test3 numThread = new Test3();
28       //4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
29       FutureTask futureTask = new FutureTask(numThread);
30       //5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
31       new Thread(futureTask).start();//用了匿名内部类
　　　　　　 /*可以和上面一样写成（相当于）：
      　　Thread thread = new Thread(futureTask);
     　　 thread.start();
 　　　　　　 */
32 
33       try {
34           //6.获取Callable中call方法的返回值
35           //get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
36           Object sum = futureTask.get();
37           System.out.println("总和为：" + sum);
38       } catch (InterruptedException e) {
39           e.printStackTrace();
40       } catch (ExecutionException e) {
41           e.printStackTrace();
42       }
43   }
44 
45 }

 1 import java.util.concurrent.ExecutorService;
 2 import java.util.concurrent.Executors;
 3 
 4 /**
 5  * 这里可以用实现Runnable的方式 也可以用实现Callable的方式
 6  * 
 7  */
 8 class Test4 implements Runnable {
 9     @Override
10     public void run() {
11         System.out.println("代码");
12     }
13 }
14 
15 public class ThreadTest4 {
16     public static void main(String[] args) {
17         // 1. 提供指定线程数量的线程池  这里设置为10
18         ExecutorService service = Executors.newFixedThreadPool(10);
19 
20         // 2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
21         service.execute(new Test4());// 适合适用于Runnable
22         // service.submit(Callable callable);//适合使用于Callable
23 
24         // 3.关闭连接池
25         service.shutdown();
26     }
27 
28 }