Java多线程实现方式主要有四种：继承Thread类、实现Runnable接口、实现Callable接口通过FutureTask包装器来创建Thread线程、使用ExecutorService、Callable、Future实现有返回结果的多线程。
其中前两种方式线程执行完后都没有返回值，后两种是带返回值的。
1、继承Thread类
创建线程的步骤：
1 定义一个类继承Thread。
2 重写run方法。
3 创建子类对象，就是创建线程对象。
4 调用线程的start方法开启线程， 一个线程一旦开启就会执行run方法中的所有代码。
注意： run方法千万不能直接调用，直接调用run方法相当于调用了一个普通的方法而已，并没有开启一个新的线程。
我们为什么要继承Thread类，并调用其的start方法才能开启线程呢？
继承Thread类：因为Thread类用来描述线程，具备线程应该有功能。那为什么不直接创建Thread类的对象呢？这样做没有错，但是该start调用的是Thread类中的run方法，而这个run方法没有做什么事情，更重要的是这个run方法中并没有定义我们需要让线程执行的代码。
package cn.itcast.thread; public class Demo1 extends Thread { @Override public void run() { //自定义线程的任务代码 for(int i = 0 ; i< 100 ; i++){ System.out.println("自定义线程："+i); } } //每个线程都有自己的任务代码..... public static void main(String[] args) { //创建线程对象 Demo1 d = new Demo1(); //开启线程 d.start(); for(int i = 0 ; i< 100 ; i++){ System.out.println("主线程："+i); } } }
2、实现Runnable接口
创建线程的步骤：
1. 自定义一个类去实现Runnable接口。
2. 实现了Runnable接口的run方法， 把自定义线程的任务定义在run方法上。
3. 创建Runnable实现类的对象。
4. 创建Thread对象，并且把Runnable实现类对象作为参数传递进去。
5. 调用thread对象的start方法开启线程。
package duoxiancheng; import java.lang.Thread; public class Demo1 implements Runnable { @Override public void run() { // TODO Auto-generated method stub for (int i = 0; i < 100; i++) { System.out.println(Thread.currentThread().getName() + ":" + i); } System.out.println("当前线程对象：" + Thread.currentThread()); // 当前线程对象是： Thread System.out.println("当前对象：" + this); // this对象： Demo3的对象 } public static void main(String[] args) { //创建Runnable实现类的对象 Demo1 d = new Demo1(); //创建Thread对象，并且把Runnable实现类对象作为参数传递进去 Thread t = new Thread(d,"狗娃"); //调用thead对象的start方法开启线程。 t.start(); //主线程执行的。 for(int i = 0 ; i< 100 ; i++){ System.out.println(Thread.currentThread().getName()+":"+i); } } }
原理：创建Thread类的对象，只有创建Thread类的对象才可以创建线程。线程任务已被封装到Runnable接口的run方法中，而这个run方法所属于Runnable接口的子类对象，所以将这个子类对象作为参数传递给Thread的构造函数，这样，线程对象创建时就可以明确要运行的线程的任务。
Thread类使用了target变量记录了Runnable实现类对象。
public void run() { //run方法的代码是属于线程的任务代码
if (target != null) {
target.run(); // 调用了Runanble实现类对象的run方法。 就是相当于把Runnable实现类的run方法作为了线程的任务代码去执行了。
}
}
如下：
Runnable方法：
Thread构造方法：
实现Runnable的好处
第二种方式实现Runnable接口避免了单继承的局限性，所以较为常用。实现Runnable接口的方式，更加的符合面向对象，线程分为两部分，一部分线程对象，一部分线程任务。继承Thread类，线程对象和线程任务耦合在一起。一旦创建Thread类的子类对象，既是线程对象，有又有线程任务。实现runnable接口，将线程任务单独分离出来封装成对象，类型就是Runnable接口类型。Runnable接口对线程对象和线程任务进行解耦。
3、实现Callable接口
Callable与Runnable的区别
- Runnable执行方法是run(),Callable是call()
- 实现Runnable接口的任务线程无返回值；实现Callable接口的任务线程能返回执行结果
- call方法可以抛出异常，run方法若有异常只能在内部消化
Runnable只有一个run()函数，用于将耗时操作写在其中，该函数没有返回值。然后使用某个线程去执行该runnable即可实现多线程，Thread类在调用start()函数后就是执行的是Runnable的run()函数。Runnable的声明如下 :
Callable与Runnable的功能大致相似，Callable中有一个call()函数，但是call()函数有返回值，而Runnable的run()函数不能将结果返回给客户程序。Callable的声明如下 :
可以看到，这是一个泛型接口，call()函数返回的类型就是客户程序传递进来的V类型。
l ExecutorService：线程池类
l <T> Future<T> submit(Callable<T> task)：获取线程池中的某一个线程对象，并执行线程中的call()方法
l Future接口：用来记录线程任务执行完毕后产生的结果。线程池创建与使用
使用线程池中线程对象的步骤：
1.创建线程池对象
2.创建Callable接口子类对象
3.提交Callable接口子类对象
4.关闭线程池
package duoxiancheng; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class Demo5 { public static void main(String[] args) { //创建线程池对象 ExecutorService service = Executors.newFixedThreadPool(2);//包含2个线程对象 //创建Callable对象 MyCallable c = new MyCallable(); //从线程池中获取线程对象,然后调用MyRunnable中的run() service.submit(c); //再获取个教练 service.submit(c); service.submit(c); //注意：submit方法调用结束后，程序并不终止，是因为线程池控制了线程的关闭。将使用完的线程又归还到了线程池中 //关闭线程池 //service.shutdown(); } }
package duoxiancheng; import java.util.concurrent.Callable; public class MyCallable implements Callable { @Override public Object call() throws Exception { System.out.println("我要一个教练:call"); Thread.sleep(2000); System.out.println("教练来了： " + Thread.currentThread().getName()); System.out.println("教我游泳,交完后,教练回到了游泳池"); return null; } }
补充：线程的匿名内部类使用
Thread /Runnable
package duoxiancheng; public class Demo2 { public static void main(String[] args) { // l 方式1：创建线程对象时，直接重写Thread类中的run方法 new Thread() { public void run() { for (int x = 0; x < 40; x++) { System.out.println(Thread.currentThread().getName() + "...X...." + x); } } }.start(); // l 方式2：使用匿名内部类的方式实现Runnable接口，重新Runnable接口中的run方法 Runnable r = new Runnable() { public void run() { for (int x = 0; x < 40; x++) { System.out.println(Thread.currentThread().getName() + "...Y...." + x); } } }; new Thread(r).start(); } }
线程的生命周期状态图
线程常用的方法：
Thread(String name) 初始化线程的名字
setName(String name) 设置线程对象名
getName() 返回线程的名字
static sleep() 哪个线程执行了sleep的代码，那么该线程就会睡眠指定毫秒数。
currentThread() 返回当前执行该方法的线程对象引用。
getPriority() 返回当前线程对象的优先级，默认线程的优先级是5
setPriority(int newPriority) 设置线程的优先级，虽然设置了线程的优先级，但是具体的实现取决于底层的操作系统的实现（最大的优先级是10 ，最小的1 ， 默认是5）。
注：优先级越高的线程也不一定先执行完，只不过拿到CPU的概率变大了些。
摘：https://blog.csdn.net/Liu_yunzhao/article/details/78504287?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-3.nonecase&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-3.nonecase