Java多线程的11种创建方式以及纠正网上流传很久的一个谬误

版权声明:本文为博主原创文章,遵循 CC 4.0 by-sa 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://linuxstyle.blog.csdn.net/article/details/87884077

创建线程比较传统的方式是继承Thread类和实现Runnable,也可以用内部类,Lambda表达式,线程池,FutureTask等。

经常面试会问到继承Thread类和实现Runnable的区别,然后网上会流传如下这样的说法,这是错误的。

流传很久的错误说法:

这个说法是举一个火车票售票的例子,大致意思是说实现Runnable接口可以实现多继承,这一点说的是正确的,但是错误的是下面的,那些例子会说实现Runnable接口的多线程可以实现共享,而继承Thread类的线程是不会共享的。其实之所以造成他们的说法看起来对是刻意在继承Thread类的时候故意新建几个线程,而成员变量又不是静态的自然是不能共享的。

下面就是那个流传很广的关于继承Thread类和实现Runnable的两种方式的“区别”的来源:

参考类似此文《创建线程的两种方式比较Thread VS Runnable

说明:上面截图中的是片面的,然后很多培训机构和很多博主还引用这个,所以有必要澄清下这个问题。

正确的说法是:继承Thread类和实现Runnable的最本质的区别是继承接口可以实现多继承。继承Thread类的一样可以实现共享。

 

先看Thread类和Runnable接口的关系

可以看到 Runnable接口就一个run方法,然后Thread类实现了这个run方法,同时自己又实现了很多其他方法。

1.继承Thread类和重写run()方法

public class MyThread extends Thread{

    private String name;
    private int i = 0;
    public MyThread(String name){
        this.name = name;
    }

    @Override
    public void run() {
        i++;
        System.out.println(name+" i计数为:"+i+"    "+Thread.currentThread().getName());
    }
}
public class MyThreadTest {
    public static void main(String[] args) {
        MyThread mt1 = new MyThread("线程");
        Thread t1 = new Thread(mt1);
        Thread t2 = new Thread(mt1);
        Thread t3 = new Thread(mt1);

        t1.start();
        t2.start();
        t3.start();
    }
}

 

说明:这样就实现了所谓继承的方式不能多个线程处理同一个资源的情况。

你可以自定义线程的name,这样就不会是Thread-0,1,2,3这样的系统生成的name了。

 

再修改代码:

public class MyThreadTest {
    public static void main(String[] args) {
        MyThread t1 = new MyThread("线程1");
        MyThread t2 = new MyThread("线程2");
        MyThread t3 = new MyThread("线程3");

        t1.start();
        t2.start();
        t3.start();
    }
}

这次每个线程之间就不会共享数据,也就是那些谬误中的用法。

 

2.实现Runnable接口

public class MyThreadRunnable implements Runnable{
    private String name;
    private int i = 0;
    public MyThreadRunnable(String name){
        this.name = name;
    }

    @Override
    public void run() {
        i++;
        System.out.println(name+" i计数为:"+i+"    "+Thread.currentThread().getName());
    }
}
public class MyThreadTest {
    public static void main(String[] args) {
        //MyThread t1 = new MyThread("线程1");
        //MyThread t2 = new MyThread("线程2");
        //MyThread t3 = new MyThread("线程3");

        MyThreadRunnable mt=new MyThreadRunnable("线程1");
        Thread t1 = new Thread(mt);
        Thread t2 = new Thread(mt);
        Thread t3 = new Thread(mt);
        t1.start();
        t2.start();
        t3.start();
    }
}

实现Runnable接口可以共享变量。

 

再把代码改一改:

public class MyThreadTest {
    public static void main(String[] args) {
        //MyThread t1 = new MyThread("线程1");
        //MyThread t2 = new MyThread("线程2");
        //MyThread t3 = new MyThread("线程3");

        MyThreadRunnable mt1=new MyThreadRunnable("线程1");
        MyThreadRunnable mt2=new MyThreadRunnable("线程2");
        MyThreadRunnable mt3=new MyThreadRunnable("线程3");
        Thread t1 = new Thread(mt1);
        Thread t2 = new Thread(mt2);
        Thread t3 = new Thread(mt3);
        t1.start();
        t2.start();
        t3.start();
    }
}

这次就不会共享变量了。

所以这样就证明了共享变量和继承Thread类和实现Runnable并无关系!

 

3.实现线程创建的两种简洁方式(匿名内部类+Lambda表达式)


这种方式适合于创建启动线程次数较少的环境,一般书写更加简便。

       //方式1:相当于继承了Thread类,作为子类重写run()实现
        new Thread() {
            public void run() {
                System.out.println("匿名内部类创建线程方式1..." + Thread.currentThread().getName());
            }
        }.start();

        //方式2:实现Runnable,Runnable作为匿名内部类
        new Thread(new Runnable() {
            public void run() {
                System.out.println("匿名内部类创建线程方式2..." + Thread.currentThread().getName());
            }
        }).start();

        //方式3:Lambda表达式创建线程
        new Thread(() -> {
            System.out.println("Lambda表达式创建线程方式..." + Thread.currentThread().getName());
        }).start();

 

如果需要自定义线程名字可以修改如下:

//方式3:Lambda表达式创建线程
        new Thread(() -> {
            System.out.println("Lambda表达式创建线程方式..." + Thread.currentThread().getName());
        },"线程1").start();

 

4.实现线程的线程池方式

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPool {
    public static void main(String[] args) {
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(4);
        for (int i = 0; i < 10; i++) {
            final int index = i;
            fixedThreadPool.execute(new Runnable() {
                public void run() {
                    try {
                        System.out.println(index+ " "+Thread.currentThread().getName()+" "+DateUtil.getNowTimeString());
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
        fixedThreadPool.shutdown();
    }
}

这个帖子写的很好,还有其他几种模式: 《java常用的几种线程池比较

newCachedThreadPool

创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程。

newFixedThreadPool

创建一个指定工作线程数量的线程池。每当提交一个任务就创建一个工作线程,如果工作线程数量达到线程池初始的最大数,则将提交的任务存入到池队列中。

FixedThreadPool是一个典型且优秀的线程池,它具有线程池提高程序效率和节省创建线程时所耗的开销的优点。但是,在线程池空闲时,即线程池中没有可运行任务时,它不会释放工作线程,还会占用一定的系统资源。

newSingleThreadExecutor

创建一个单线程化的Executor,即只创建唯一的工作者线程来执行任务,它只会用唯一的工作线程来执行任务,保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。如果这个线程异常结束,会有另一个取代它,保证顺序执行。单工作线程最大的特点是可保证顺序地执行各个任务,并且在任意给定的时间不会有多个线程是活动的。

newScheduleThreadPool

创建一个定长的线程池,而且支持定时的以及周期性的任务执行,支持定时及周期性任务执行。

5.实现异步的Future,FutureTask,CompletableFuture方式

本质还是线程,因为Java目前语言层面没有协程,需要三方类库或者修改JVM才可以,

参考本人另一帖:《异步编程原理以及Java实现》,具体源码分析都有本质还是调用class Executors,只不过是这种方式可以回调而已。原因是继承和实现了Runnable接口这2种方式创建线程都有一个缺陷就是:在执行完任务之后无法获取执行结果。

自从Java 1.5开始,就提供了Callable和Future,通过它们可以在任务执行完毕之后得到任务执行结果

虽然 Future 以及相关使用方法提供了异步执行任务的能力,但是对于结果的获取却是很不方便,只能通过阻塞或者轮询的方式得到任务的结果。阻塞的方式显然和我们的异步编程的初衷相违背,轮询的方式又会耗费无谓的 CPU 资源,而且也不能及时地得到计算结果。

在Java8中,CompletableFuture提供了非常强大的Future的扩展功能,可以帮助我们简化异步编程的复杂性,并且提供了函数式编程的能力,可以通过回调的方式处理计算结果,也提供了转换和组合 CompletableFuture 的方法。

CompletableFuture基本用法

6.定时器方式

这种方式不是为了实现线程,但是他确实是起了一个线程

import java.util.Timer;
import java.util.TimerTask;

public class TimerTest {
    public static void main(String[] args) {
        Timer timer = new Timer();
        timer.schedule(new

                               TimerTask() {
                                   @Override
                                   public void run() {
                                       System.out.println("定时任务延迟0(即立刻执行),每隔1000ms执行一次"+ " "+Thread.currentThread().getName()+" "+ DateUtil.getNowTimeString());
                                   }
                               }, 0, 1000);
    }
}

public abstract class TimerTask implements Runnable

 

 从类图可以看出TimerTask实现了Runnable接口的run()方法。

详细分析可以参考《Java 定时器 Timer 源码分析和使用建议》:

Timer 可以按计划执行重复的任务或者定时执行指定任务,这是因为 Timer 内部利用了一个后台线程 TimerThread 有计划地执行指定任务。

  • Timer:是一个实用工具类,该类用来调度一个线程(schedule a thread),使它可以在将来某一时刻执行。 Java 的 Timer 类可以调度一个任务运行一次或定期循环运行。 Timer tasks should complete quickly. 即定时器中的操作要尽可能花费短的时间。

  • TimerTask:一个抽象类,它实现了 Runnable 接口。我们需要扩展该类以便创建自己的 TimerTask ,这个 TimerTask 可以被 Timer 调度。

一个 Timer 对象对应的是单个后台线程,其内部维护了一个 TaskQueue,用于顺序执行计时器任务 TimeTask 。

 

7.Spring异步任务支持

@EnableAsync和@Async开始异步任务支持

Spring通过任务执行器(TaskExecutor)来实现多线程和并发编程。使用ThreadPoolTaskExecutor可实现一个基于线程池的TaskExecutor.在开发中实现异步任务,我们可以在配置类中添加@EnableAsync开始对异步任务的支持,并在相应的方法中使用@Async注解来声明一个异步任务。 
详细参考《@EnableAsync和@Async开始异步任务支持

 

8.可以用并行流创建线程

import java.util.Arrays;
import java.util.stream.Collectors;

public class StreamParallel {
    public static void main(String args[]) {

        for (int i = 0; i < 1000000; i++) {
            Arrays.asList(1, 2, 3, 4, 5, 6, 7, 9, 8, 0, 1)
                    .stream()
                    .parallel()
                    .collect(Collectors.groupingBy(x -> x % 10))
                    .forEach((x, y) -> System.out.println(x + ":" + y));
        }
    }
}

 可以看到默认的parallel计算启动了三个线程进行并行。

参考《Java8 Stream 并行计算实现的原理

Java 并发编程:线程间的协作(wait/notify/sleep/yield/join)

展开阅读全文

没有更多推荐了,返回首页