线程是程序的一条执行线索，执行路径，是程序使用cpu的最小单位，是在进程中独立运行的子任务，每一个线程都有自己的功能，那java线程创建的三种方式有哪些?下面来我们就来给大家讲解一下创建java线程方式。
第一种，通过继承Thread类创建线程类
通过继承Thread类来创建并启动多线程的步骤如下：
1、定义一个类继承Thread类，并重写Thread类的run()方法，run()方法的方法体就是线程要完成的任务，因此把run()称为线程的执行体;
2、创建该类的实例对象，即创建了线程对象;
3、调用线程对象的start()方法来启动线程;
代码实例：
public class ExtendThread extends Thread
{
private int i;
public static void main(String[] args)
{
for (int j = 0; j < 50; j++)
{
//调用Thread类的currentThread()方法获取当前线程
System.out.println(Thread.currentThread()
.getName() + " " + j);
if (j == 10)
{
//创建并启动第一个线程
new ExtendThread()
.start();
//创建并启动第二个线程
new ExtendThread()
.start();
}
}
}
public void run()
{
for (; i < 100; i++)
{
//当通过继承Thread类的方式实现多线程时，可以直接使用this获取当前执行的线程
System.out.println(this.getName() + " " + i);
}
}
}代码相关：
1、上述的getName()方法是返回当前线程的名字，也可以通过setName()方法设置当前线程的名字;
2、当JAVA程序运行后，程序至少会创建一个主线程(自动)，主线程的线程执行体不是由run()方法确定的，而是由main()方法确定的;
3、在默认情况下，主线程的线程名字为main，用户创建的线程依次为Thread—1、Thread—2、....、Thread—3;
代码分析：
这是代码运行后的截图，从图中可以看出：
1、有三个线程：main、Thread-0 、Thread-1
2、Thread-0 、Thread-1两个线程输出的成员变量 i 的值不连续(这里的 i 是实例变量而不是局部变量)。因为：通过继承Thread类实现多线程时，每个线程的创建都要创建不同的子类对象，导致Thread-0 、Thread-1两个线程不能共享成员变量 i ;
3、线程的执行是抢占式，并没有说Thread-0 或者Thread-1一直占用CPU(这也与线程优先级有关，这里Thread-0 、Thread-1线程优先级相同，关于线程优先级的知识这里不做展开);
2.2 第二种，通过实现Runnable接口创建线程类
这种方式创建并启动多线程的步骤如下：
1、定义一个类实现Runnable接口;
2、创建该类的实例对象obj;
3、将obj作为构造器参数传入Thread类实例对象，这个对象才是真正的线程对象;
4、调用线程对象的start()方法启动该线程;
代码实例：
public class ImpRunnable implements Runnable
{
private int i;
@Override
public void run()
{
for (; i < 50; i++)
{
//当线程类实现Runnable接口时，要获取当前线程对象只有通过Thread.currentThread()获取
System.out.println(Thread.currentThread()
.getName() + " " + i);
}
}
public static void main(String[] args)
{
for (int j = 0; j < 30; j++)
{
System.out.println(Thread.currentThread()
.getName() + " " + j);
if (j == 10)
{
ImpRunnable thread_target = new ImpRunnable();
//通过new Thread(target,name)的方式创建线程
new Thread(thread_target, "线程1")
.start();
new Thread(thread_target, "线程2")
.start();
}
}
}
}代码相关：
1、实现Runnable接口的类的实例对象仅仅作为Thread对象的target，Runnable实现类里包含的run()方法仅仅作为线程执行体，而实际的线程对象依然是Thread实例，这里的Thread实例负责执行其target的run()方法;
2、通过实现Runnable接口来实现多线程时，要获取当前线程对象只能通过Thread.currentThread()方法，而不能通过this关键字获取;
3、从JAVA8开始，Runnable接口使用了@FunctionlInterface修饰，也就是说Runnable接口是函数式接口，可使用lambda表达式创建对象，使用lambda表达式就可以不像上述代码一样还要创建一个实现Runnable接口的类，然后再创建类的实例。
代码分析：
这是代码运行后的结果截图，从图中可以看出：
1、线程1和线程2输出的成员变量i是连续的，也就是说通过这种方式创建线程，可以使多线程共享线程类的实例变量，因为这里的多个线程都使用了同一个target实例变量。但是，当你使用我上述的代码运行的时候，你会发现，其实结果有些并不连续，这是因为多个线程访问同一资源时，如果资源没有加锁，那么会出现线程安全问题(这是线程同步的知识，这里不展开);
2.3 第三种，通过Callable和Future接口创建线程
通过这两个接口创建线程，你要知道这两个接口的作用，下面我们就来了解这两个接口：通过实现Runnable接口创建多线程时，Thread类的作用就是把run()方法包装成线程的执行体，那么，是否可以直接把任意方法都包装成线程的执行体呢?从JAVA5开始，JAVA提供提供了Callable接口，该接口是Runnable接口的增强版，Callable接口提供了一个call()方法可以作为线程执行体，但call()方法比run()方法功能更强大，call()方法的功能的强大体现在：
1、call()方法可以有返回值;
2、call()方法可以声明抛出异常;
从这里可以看出，完全可以提供一个Callable对象作为Thread的target，而该线程的线程执行体就是call()方法。但问题是：Callable接口是JAVA新增的接口，而且它不是Runnable接口的子接口，所以Callable对象不能直接作为Thread的target。还有一个原因就是：call()方法有返回值，call()方法不是直接调用，而是作为线程执行体被调用的，所以这里涉及获取call()方法返回值的问题。
于是，JAVA5提供了Future接口来代表Callable接口里call()方法的返回值，并为Future接口提供了一个FutureTask实现类，该类实现了Future接口，并实现了Runnable接口，所以FutureTask可以作为Thread类的target，同时也解决了Callable对象不能作为Thread类的target这一问题。
在Future接口里定义了如下几个公共方法来控制与它关联的Callable任务：
1、boolean cancel(boolean mayInterruptIfRunning)：试图取消Future里关联的Callable任务;
2、V get()：返回Callable任务里call()方法的返回值，调用该方法将导致程序阻塞，必须等到子线程结束以后才会得到返回值;
3、V get(long timeout, TimeUnit unit)：返回Callable任务里call()方法的返回值。该方法让程序最多阻塞timeout和unit指定的时间，如果经过指定时间后，Callable任务依然没有返回值，将会抛出TimeoutException异常;
4、boolean isCancelled()：如果Callable任务正常完成前被取消，则返回true;
5、boolean isDone()：如果Callable任务已经完成， 则返回true;
这种方式创建并启动多线程的步骤如下：
1、创建Callable接口实现类，并实现call()方法，该方法将作为线程执行体，且该方法有返回值，再创建Callable实现类的实例;
2、使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值;
3、使用FutureTask对象作为Thread对象的target创建并启动新线程;
4、调用FutureTask对象的get()方法来获得子线程执行结束后的返回值。
代码实例：
public class ThirdThreadImp
{
public static void main(String[] args)
{
//这里call()方法的重写是采用lambda表达式，没有新建一个Callable接口的实现类
FutureTask < Integer > task = new FutureTask < Integer > ((Callable < Integer > )() - >
{
int i = 0;
for (; i < 50; i++)
{
System.out.println(Thread.currentThread()
.getName() +
" 的线程执行体内的循环变量i的值为：" + i);
}
//call()方法的返回值
return i;
});
for (int j = 0; j < 50; j++)
{
System.out.println(Thread.currentThread()
.getName() +
" 大循环的循环变量j的值为：" + j);
if (j == 20)
{
new Thread(task, "有返回值的线程")
.start();
}
}
try
{
System.out.println("子线程的返回值：" + task.get());
}
catch (Exception e)
{
e.printStackTrace();
}
}
}代码相关：
1、上述代码没有使用创建一个实现Callable接口的类，然后创建一个实现类实例的做法。因为，从JAVA8开始可以直接使用Lambda表达式创建Callable对象，所以上面的代码使用了Lambda表达式;
2、call()方法的返回值类型与创建FutureTask对象时<>里的类型一致。
代码分析：
Java创建线程主要有继承Thread类创建线程类，通过Runnable接口创建线程类以及通过Callable和Future创建线程这几种方式， java线程是java中重要知识点，因此对于我们一定要学会创建方式!最后大家如果想要了解更多java入门知识，敬请关注奇Q工具网。
推荐阅读：