第一次分享，浅谈实现并发的几种方式

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);

}

执行结果：
1

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);
            });
        }
    }
}

执行结果：
2
3
4
1
0

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);
    }
}

执行结果：
1
1
1
1
1
任务经过2s延迟后，没1秒执行一次任务

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后同时打印出结果，无序的打印结果如下：
4
5
3
1
2
6

非常感谢大家浏览我第一次做的小分享，如果有不正确的地方，欢迎指出，共同努力共同进步。争取以后可以在学习过程中，多多分享自己的所知，养成一个很好的学习习惯，哪怕是一小点，也是进步的过程，越努力越幸运！