并发编程学习笔记(1)----多线程几种实现方式

  多线程是指机器支持在同一时间执行多个线程，能够提高cpu的利用率 ，提高程序的执行效率。

（1）继承Thread类

多线程可以通过继承Thread类并重新Thread的run方法来启动多线程。然后通过Thread的start方法来启动线程。上代码：

package com.wangx.thread.t1;

public class Demo1 extends Thread {

    Demo1(String name) {
        super(name);
    }
    @Override
    public void run() {
        while (!interrupted()) {
            System.out.println("线程" + Thread.currentThread().getName() + "执行了。。。。");
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Demo1 demo1 = new Demo1("one");
        Demo1 demo2 = new Demo1("two");
        demo1.start();
        demo2.start();
        demo1.interrupt();
    }
}

这里也顺便用了线程的中断，当希望一个线程不再执行时，就是用interrupt()方法来进行中断，此时的的线程对象将不会再执行，interrupted()方法判断线程是否中断，返回boolean值，当当前线程被中断时返回false，使用interrupted()方法可以避免报InterruptedException异常。

（2）实现Runnable接口

Runnable接口中只有一个run方法，实现Runnable接口的run方法作为任务处理方法，将Runnable的实现类对象传入到Thread的构造中，创建线程，并使用Thread.start()启动线程。代码：

package com.wangx.thread.t1;

public class Demo2 implements Runnable {

    /**
     * 重写run方法
     */
    @Override
    public void run() {
        System.out.println("执行了");
    }

    public static void main(String[] args) {

        Demo2 demo2 = new Demo2();
        //将demo2传入到Thread中
        Thread thread = new Thread(demo2);
        Thread thread1 = new Thread(demo2);

        thread.start();
        thread1.start();
    }
}

这里的Runnable接口其实是作为一个线程任务处理器，查看Thread中的run方法和构造方法可以看出，但传入的target(Runnable对象)不为空时，执行Runnable的run方法，所以通过启动线程时实际先执行的还是Thread中的run方法去调用target的run方法。Thread中的run()方法源码如下：

public void run() {
        if (target != null) {
            target.run();
        }
    }

（3）匿名内部类方法

匿名内部类其实跟继承Thread类并重写run方法原理一样，都是通过覆盖父类run方法，执行当前对象的run方法的方式来执行只需要处理的任务，只是写法上跟简洁，并且只会执行一次，如果任务只需要执行一次时并且减少代码量时可以使用，代码如下：

package com.wangx.thread.t1;

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

        //匿名内部类启动多线程
        new Thread(){
            @Override
            public void run() {
                System.out.println("Thread in running");
            }
        }.start();
    }
}

还可以通过Runnable的匿名内部类来实现，原理与第二点一致，代码如下：

package com.wangx.thread.t1;

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

        //匿名内部类启动多线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("runnable thread is running");
            }
        }).start();
    }
}

在这里需要注意的时，当同时使用Thread的匿名内部类和Runnable接口的匿名内部类同时使用时，此时执行的是Thread的run方法，而不会执行Runnable的run方法，原因是根据源码可以看出此时run方法已经被重写，所以不会调用target.run语句，所以Runnable的run方法不会执行。代码：

package com.wangx.thread.t1;

public class Demo3 {
    public static void main(String[] args) {
        //Thread匿名内部类和Runnable匿名内部类同时存在时，打印sub is running
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("Runnable");
            }
        }){
            @Override
            public void run() {
                System.out.println("sub is running");
            }
        }.start();
    }
}

（4）创建带返回值的线程

实现Callable<T>泛型方法，重写call方法，泛型传入什么类型的值，call就返回什么类型的值，并使用FutureTask接收Callable对象，FutureTask的泛型为Callable中传入的类型，将
FutrueTask对象传入到Thread中启动线程，并使用FutureTask的get方法获取到call方法的返回值，代码如下：

package com.wangx.thread.t1;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class Demo4 implements Callable<Integer> {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Demo4 demo4 = new Demo4();

        //通过demo4创建task对象
        FutureTask<Integer> task = new FutureTask<>(demo4);

        //通过task创建并启动线程
        Thread thread = new Thread(task);
        thread.start();
        Integer result = task.get();
        System.out.println("计算结果为：" + result);
    }

    @Override
    public Integer call() throws Exception {
        System.out.println("正在进行紧张的计算....");
        Thread.sleep(1000);
        return 1;
    }
}

Thread中可以接接收FutureTask是因为FutureTask是Runnable的实现类，所以也可以说FutureTask是Runnable的另类实现。

（5）线程池的方式

由于线程的创建和销毁都会消耗过多的内存资源，所以在jdk5之后JAVA新增了线程池的概念，ThreadPoolExecutor是线程池的核心类，它重载了很多的构造方法让我们构造一个线程池，在线程池中创建指定多个的线程，执行任务时，将从线程池中取出线程去执行任务，任务执行完成后将线程归还到线程池中。线程池不用频繁的创建和销毁线程池，减少了资源的消耗，提高了性能，可以直接通过new ThreadPoolExecutor()来指定自己创建线程池，也可以使用Executors中的静态方法来创建各种类型的线程池，这里先创建一个制定大小的线程池，代码如下：

package com.wangx.thread.t1;

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

public class Demo6 {
    public static void main(String[] args) {
        //创建线程池大小为10的线程池
        ExecutorService executor = Executors.newFixedThreadPool(10);
        //循环执行100次，打印线程名字，发现总是只用10个线程在执行
        for (int i = 0; i < 100; i++){
            executor.execute(()-> {
                System.out.println(Thread.currentThread().getName());
            });
        }
        executor.shutdown();
    }
}

 executor.execute()传入Runnable对象，执行任务，这里使用lambda表达式写法，其实就是一个Runnable匿名对象，打印当前线程名称。当任务100次循环之后我们发现程序并没有结束，
这是因为线程池仍然存活，此时调用executor.shutdown();方法关闭线程池，结束程序。因为Executors中的静态方法也是通过ThreadPoolExecutor来创建的，所以这里就不写直接创建
的案例了，关于ThreadPoolExecutor构造方法的个参数作用下一节将会详解。
（6）在spring3+中使用多线程
spring3之后的版本提供了对多线程的支持，这里案例是spring boot项目为例的，方便引入spring的依赖。
在spring boot中使用多线程需要使用@EnableAsync注解来开启异步执行的支持，然后在需要执行的方法上加上@Async标记该方法为异步方法，之后直接通过bean调用该方法可以发现该方法是
异步执行的，实例代码为：

package com.example.springthread;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.scheduling.annotation.EnableAsync;
/**
*springboot启动类，这里也用做了配置类
*/
@SpringBootApplication
//开启注解
@EnableAsync
public class SpringthreadApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(SpringthreadApplication.class, args);

        DemoService demoService = context.getBean(DemoService.class);

        demoService.a();
        demoService.b();
    }
}
/*******************异步方法所在的bean*************************/
package com.example.springthread;

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;


@Service
public class DemoService {
//标记方法为异步方法
    @Async
    public void a() {
        while (true){
            System.out.println("a is running");
        }
    }
    @Async
    public void b() {
        while (true){
            System.out.println("b is running");
        }
    }
}

启动springboot，调用DemoService的a/b方法，可以看到他们异步执行。这里只是为了方便引入spring的依赖，直接使用spring也是可以实现异步方法调用的spring也支持计划任务，使用@EnableScheduling开启计划任务，@Scheduled标记计划任务的方法，在注解中传入相应的执行时间和周期即可实现计划任务

（7）创建定时任务
在java.util包中提供了一个Timer类可以用来创建定时任务，可以指定某个时间开始执行，之后每隔多长时间执行一次。代码如下：

package com.wangx.thread.t1;

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

public class Demo5 {
    public static void main(String[] args) {
        Timer timer = new Timer();
        //  创建1秒后开始中，没隔1秒执行一次的定时任务
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("timer task is running");
            }
        },1000, 1000);
    }
}

Timer接收一个TimerTask为要执行的任务，其余参数为需要执行的时间方式，可以进入Timer的源码查看个参数的意义，构建自己想要的计划任务。

本章主要是为了回顾java生态中各种多线程的实现方式，并不涉及太多概念和原理问题，具体的原理将会在后面的学习中逐渐补上。