深入理解JAVA多线程---线程的几种创建方法

前言

现代计算机的处理能力越发的强大,多线程可谓是程序员必须要熟练应用的技能,本人将记录自己学习多线程总结出来的要点希望对读者有一丝的启发.文章大部分来自书籍JAVA多线程编程核心技术,也推荐大家对多线程有一定了解后去品读一定会有很多的收获.

什么是进程和线程?

在学习多线程之前我们必须要对进程和线程有着很清晰的认识.

进程:是程序在一个数据集合上运行的过程,它是系统进行资源分配和调度的基本单位.
线程:是操作系统运算调度的最小单位,它包含在进程之中,是进程的实际运作单位.

初识线程

public class ThreadBegin {
    //初识线程
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName());
    }
}

这里会输出main,这个main就代表主线程.(需要注意的是这个main和主方法名main没有任何关系只是名字相同而已,也就是一个代表线程名字,一个代表方法名字).
既然要学习多线程那必须的要知道,如何开启一个线程?开启线程的方法

线程的几种创建方法

继承Thread类

创建步骤有三步:

1. 创建你自己的线程类继承Thread,并重写该类的run()方法,run()方法中就是需要这条线程执行的任务.
2. 创建你写的线程类的实例,也就是创建线程对象.
3. 调用实例的start()方法,启动线程.

	public static class MyThread extends Thread{
        @Override
        public void run() {
            System.out.println("继承Thread类创建的线程");
        }
    }

    public static void main(String[] args) {
        myThread myThread = new myThread();
        myThread.start();
    }

继承Runnable接口

创建步骤也是三步和继承Thread基本类似:

1. 创建你自己的线程类继承Runnable,并重写该类的run()方法,run()方法中就是需要这条线程执行的任务.
2. 创建你写的线程类的实例,然后这个实例作为Thread的target(Thread的构造方法中有一个就是传入Runnable接口),这里的Thread才算创建好的线程对象.
3. 调用线程对象的start()方法,启动线程.

	public static class MyThread1 implements Runnable{

        @Override
        public void run() {
            System.out.println("继承Runnable接口创建的线程");
        }
    }

    public static void main(String[] args) {
        MyThread1 myThread1 = new MyThread1();
        Thread thread = new Thread(myThread1);
        thread.start();
    }

这里需要提及一下继承Runnable接口实现多线程的优点:

• 避免了继承Thread类的单继承的局限性。
• 实现Runnable接口降低了线程对象和线程任务的耦合性，增强了程序的可扩展性。
• 实现Runnable接口将线程单独进行对象的封装，更符合面向对象思想。
  因此在实际开发中可以更多的使用继承Runnable接口来实现多线程.
  这里附上匿名内部类创建方法和lambda表达式创建线程的方法可以减少很多代码

 //匿名内部类创建线程
    public static void myThreadNiMing(){
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("匿名内部类方法创建线程"+Thread.currentThread().getName());
            }
        }).start();
    }

    //lambda表达式创建线程
    public static void myThreadLambda(){
        new Thread(()->{
            System.out.println("lambda表达式方法创建线程"+Thread.currentThread().getName());
        }).start();
    }

    public static void main(String[] args) {
        myThreadLambda();
        myThreadNiMing();
    }

使用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这一问题。

步骤如下:

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、上面的代码使用了Lambda表达式,也可以使用创建Callable实例放入Future来实现；
2、call()方法的返回值类型与创建FutureTask对象时<>里的类型一致。
代码分析：
只看最后一行输出可知：调用FutureTask对象的get()方法，必须等到子线程结束以后，才会有返回值。

使用线程池创建线程

这里篇幅较长,放在了后面详解有兴趣的可以移步.

总结几种创建方法的优缺点

创建方式可以分为两类,一类是继承Thread类,另一种是继承Runnable和Callable接口.

通过继承Thread类实现多线程：
优点：
1、实现起来简单，而且要获取当前线程，无需调用Thread.currentThread()方法，直接使用this即可获取当前线程；

缺点：
1、线程类已经继承Thread类了，就不能再继承其他类；
2、多个线程不能共享同一份资源（如前面分析的成员变量 i ）；

通过实现Runnable接口或者Callable接口实现多线程：

优点：
1、线程类只是实现了接口，还可以继承其他类；
2、多个线程可以使用同一个target对象，适合多个线程处理同一份资源的情况。

缺点：
1、通过这种方式实现多线程，相较于第一类方式，编程较复杂；
2、要访问当前线程，必须调用Thread.currentThread()方法。

建议多采用第二种方法创建线程.