JDK5.0以后Java多线程的实现方式变成了四种，下面来简单的列举一下，若是须要更深刻的了解，强烈建议阅读一下源码。java
1、继承Thread类重写run()方法：多线程
1. 建立一个继承于Thread类的子类
2. 重写Thread类的run() --> 将此线程执行的操做声明在run()中
3. 建立Thread类的子类的对象
4. 经过此对象调用start()
ide
1 // 一、 建立一个继承于Thread类的子类 2 class Test1 extends Thread { 3 4 // 二、 重写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 // 三、 建立Thread类的子类的对象 17 Test1 test1 = new Test1(); 18 19 //多线程固然能够建立多个对象来开启多个线程 20 Test1 test2 = new Test1(); 21 22 // 四、经过此对象调用start()方法启动线程 23 //start()方法的做用：1）启动当前线程 2）调用当前线程的run()方法 24 test1.start(); 25 test2.start(); 26 } 27 }
顺便插一句并非test1先调用了start()方法就必定先比test2先执行，不清楚的小伙伴建议先了解一下多线程的概念，这里主要是对实现多线程的几种方式简单总结，概念再也不赘述。学习
2、实现Runnable接口：spa
1. 建立一个实现Runnable接口的类
2. 实现Runnable中的run()方法
3. 建立实现类的对象
4. 将此对象做为参数传递到Thread类的构造器中，建立Thread类的对象
5. 经过Thread类的对象调用start()
线程
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 }
这种实现的方式没有类的单继承性的局限性更适合处理多个线程有共享数据的状况。code
3、实现Callable接口对象
1.建立Callable的实现类blog
2.实现call方法，将此线程须要执行的操做声明在call()中继承
3.建立Callable接口实现类的对象
4.将此Callable接口实现类的对象做为传递到FutureTask构造器中，建立FutureTask的对象
5.将FutureTask的对象做为参数传递到Thread类的构造器中，建立Thread对象，并调用start()
6.获取Callable中call方法的返回值
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 }
这种建立线程的方式更加的麻烦，可是人家相比较实现Runnable接口的方式更强大
相比实现Runnable接口的好处;
1. call()能够有返回值
2. call()能够抛出异常，被外面的操做捕获，获取异常的信息
3. Callable支持泛型
4、线程池
1. 提供指定线程数量的线程池
2.执行指定的线程的操做。须要提供实现Runnable接口或Callable接口实现类的对象
3.关闭链接池
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 }
这种方式的好处：
1.提升响应速度（减小了建立新线程的时间）
2.下降资源消耗（重复利用线程池中线程，不须要每次都建立）
3.便于线程管理
以上简单列举了建立线程的四种方式，有很多东西没有写；尤为是第四种，设置线程池属性等都没有演示。对于还在学习基础的小伙伴来讲，前两种须要先重点掌握，后面两种能够先了解一下，等有一些多线程基础以后再进行后续学习。