浅谈实现并发的几种方式

java实现并发的七种方式
Java多线程实现方式大概可以有七种实现方式：继承Thread类、实现Runnable接口、实现Callable接口、使用线程池、使用Timer定时器、内部类实现、jdk1.8的stream

1.继承Thread类
Thread类本质上是实现了Runnable接口的一个实例，代表一个线程的实例。启动方法就是通过继承了Thread类的start()实例方法。执行run()方法（重写的）。就可以启动新线程并执行自己定义。例如：

//实现方法的类
public class Demo1 extends Thread {

public void run(){
    System.out.println("继承Thread类");
}

}

//执行的方法
public static void main(String[] args) {

    Demo1 demo1=new Demo1();
    demo1.start();

}

执行结果：
继承Thread类

2.实现Runnable接口
由于java是单继承的，那么在平时开发中就提倡使用接口的方式实现。则需要实现多线程的类通过实现Runnable接口的run方法。通过Thread的start()方法进行启动，例如：

//实现的方法类：
public class Demo2 implements Runnable {

@Override
public void run() {
    System.out.println("实现runnable接口");
}

//执行方法：
public static void main(String[] args) {

    Demo2 demo2=new Demo2();
    Thread thread=new Thread(demo2);
    thread.start();

}

执行结果：
实现runnable接口

3.通过内部类的方式实现多线程
直接可以通过Thread类的start()方法进行实现，因为Thread类实现了Runnable接口，并重写了run方法，在run方法中实现自己的逻辑，例如：

//这里通过了CountDownLatch，来进行阻塞，来观察两个线程的启动，这样更加体现的明显一些：
public static CountDownLatch countDownLatch=new CountDownLatch(2);

public static void main(String[] args) {
    new Thread(()->{
        countDownLatch.countDown();
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("T1");
    }).start();

    new Thread(()->{
        countDownLatch.countDown();
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("T2");
    }).start();

}

结果：
第一次：
T2
T1
第二次：
T1
T2

4.通过实现Callable接口
通过实现Callable接口的call方法，可以通过FutureTask的get()方法来获取call方法中的返回值，具体实现如下：

//实现类方法：
public class Demo3 implements Callable {

@Override
public Object call() {
    return "1";
}

}

//执行方法：
public static void main(String[] args) {

    //创建实现类对象
    Callable demo3=new Demo3();
    FutureTask oneTask = new FutureTask(demo3);
    Thread thread=new Thread(oneTask);
    thread.start();
    Object o = null;
    try {
        //获取返回值
        o = oneTask.get();
    } catch (InterruptedException e) {
        e.printStackTrace();
    } catch (ExecutionException e) {
        e.printStackTrace();
    }
    System.out.println(o);

}

执行结果：

5.通过线程池来实现多线程
线程池可以根据不同的场景来选择不同的线程池来进行实现，这里我仅使用其中之一进行演示，后续会单独写一个线程池相关的单独介绍：

//实现代码如下：
public class Demo5 {

public static void main(String[] args) {
    ExecutorService executorService = Executors.newFixedThreadPool(5);
    for(int i=0;i<5;i++){
        int finalI = i;
        executorService.execute(()-> {
            System.out.println(finalI);
        });
    }
}

}

执行结果：

6.通过Timer定时器来实现多线程
就Timer来讲就是一个调度器,而TimerTask呢只是一个实现了run方法的一个类,而具体的TimerTask需要由你自己来实现,同样根据参数得不同存在多种执行方式，例如其中延迟定时任务这样:

//具体代码如下：
public class Demo6 {

public static void main(String[] args) {
    Timer timer=new Timer();
    timer.schedule(new TimerTask(){
        @Override
        public void run() {
            System.out.println(1);
        }
    },2000l,1000l);
}

}

执行结果：

7.jdk1.8通过stream实现多线程
jdk1.8 API添加了一个新的抽象称为流Stream，可以让你以一种声明的方式处理数据。
Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。
具体简单代码实现如下：

//代码实现：
public class Demo7 {

//为了更形象体现并发，通过countDownLatch进行阻塞
static CountDownLatch countDownLatch=new CountDownLatch(6);
public static void main(String[] args) {
    List list=new ArrayList<>();
    list.add(1);
    list.add(2);
    list.add(3);
    list.add(4);
    list.add(5);
    list.add(6);

    list.parallelStream().forEach(p->{
        //将所有请求在打印之前进行阻塞，方便观察
        countDownLatch.countDown();
        try {
            System.out.println("线程执行到这里啦");
            Thread.sleep(10000);
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(p);
    });
}

}

执行结果：
执行开始，所有请求都进入打印了
线程执行到这里啦
线程执行到这里啦
线程执行到这里啦
线程执行到这里啦
线程执行到这里啦
线程执行到这里啦
等待10s后同时打印出结果，无序的打印结果如下：