018线程（java基础）-CSDN博客

public class PrintThread extends Thread{
	@Override
	public void run() {
		//当前线程的名称
		String threadName = Thread.currentThread().getName();
		System.out.println("线程"+threadName+"开始计时：");
		for(int i = 1;i<=5;i++) {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("第"+i+"秒");
		}
		System.out.println("线程"+threadName+"结束计时");
	}
}

public static void main(String[] args) {
		PrintThread pt = new PrintThread();
        pt.setName("《计时器》");
		pt.start();
	}

线程《计时器》开始计时：
第1秒
第2秒
第3秒
第4秒
第5秒
线程《计时器》结束计时

2、实现Runnable接口

实现Runnable接口
重写run方法
需要借助Thread类
将对象作为Thread构造方法的参数，调用start

public class PrintRunThread implements Runnable{

	@Override
	public void run() {
		String threadName = Thread.currentThread().getName();
		System.out.println("线程"+threadName+"开始计时:");
		for(int i = 1;i<=5;i++) {
			System.out.println("第"+i+"秒");
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println("线程"+threadName+"结束计时");
	}
}

    static void test() {
		PrintRunThread pr = new PrintRunThread();
		Thread t = new Thread(pr);
		t.setName("《计时器2》");
		t.start();
	}

3、实现Callable接口

与使用runnable方式相比，callable功能更强大些：

runnable重写的run方法不如callaalbe的call方法强大，call方法可以有返回值
方法可以抛出异常
支持泛型的返回值

注意事项：

实现Callable接口
重写call()方法
需要借助FutureTask类
对象作为Future构造方法的参数
还需要借助Thread类
FutureTask类的对象作为Thread类构造方法的参数
FutureTask对象.get()可以获取call方法的返回结果

public class PrintCallThread implements Callable{
	@Override
	public Object call() throws Exception {
		int sum = 0;
		String threadName = Thread.currentThread().getName();
		System.out.println("线程"+threadName+"开始计数:");
		for(int i = 1;i<=5;i++) {
			System.out.println("加"+(i*10));
			sum+=i*10;
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println("线程"+threadName+"结束计时");
		return sum;
	}
}

    void thread3() {
		PrintCallThread pc = new PrintCallThread();
		FutureTask ft = new FutureTask(pc);
		Thread t = new Thread(ft);
		t.setName("《求和计算器》");
		t.start();
		try {
			System.out.println("最后结果为"+ft.get());//FutureTask对象.get()可以获取重写的call方法的返回值
		} catch (InterruptedException e) {
			e.printStackTrace();
		} catch (ExecutionException e) {
			e.printStackTrace();
		}
	}

输出结果：

线程《求和计算器》开始计数:
加10
加20
加30
加40
加50
线程《求和计算器》结束计时
最后结果为150

4、线程池

不建议单纯使用继承Thread或者实现Runnable接口的方式来创建线程，那样势必有创建及销毁线程耗费资源、线程上下文切换问题。同时创建过多的线程也可能引发资源耗尽的风险，这个时候引入线程池比较合理，方便线程任务的管理。所以线程池的优势就是不用反复创建和销毁线程，能提高响应速度，减少资源消耗。

两个重要的API：ExecutorService 和 Executors，用来创建线程池的

ExecutorService有个重要的子类ThreadPoolExecutor，也可以直接new ThreadPoolExecutor（）来创建线程池，我们这里先只讲用Executors来创建

（1）Executors有四个创建线程池的静态方法：

newFixedThreadPool（线程个数）；	创建固定大小的线程池
newSingleThreadExecutor();	创建只有一个线程的线程池
newCachedThreadPool()	创建一个不限线程数上限的线程池，任何提交的任务都将立即执行
newScheduledThreadPool()	创建一个不限线程数上限的线程池，提交的任务将定时周期性执行

newScheduledThreadPool

返回值都是ExecutorService

ExecutorService executorService =Executors.newFixedThreadPool(10);
//创建一个容量为10的线程池，固定容量

（2）executorService有两个重要的方法

execute（线程对象）;	参数是实现了Runnable接口的线程
submit（线程对象）;	参数是实现了Callable接口的线程

（3）executorService关闭线程池的方法

shutdownNow()	立即关闭线程池(暴力)，正在执行中的及队列中的任务会被中断
shutdown()	平滑关闭线程池，正在执行中的及队列中的任务能执行完成，后续进来的任务会被执行拒绝策略
isTerminated（）	当正在执行的任务及对列中的任务全部都执行（清空）完就会返回true

利用上述的两个线程类来测试创建的线程池：

    static void usePool() {
		ExecutorService excutor = Executors.newFixedThreadPool(10);
		PrintRunThread run = new PrintRunThread();
		PrintCallThread call = new PrintCallThread();
		
		//执行线程
		excutor.execute(run);
		excutor.submit(call);
		
		//关闭线程
		excutor.shutdown();
	}

5、Springboot中使用线程池

（1）配置类中构建线程池实例，方便调用

@Configuration
public class ThreadPoolConfig {
    @Bean(value = "threadPoolInstance")
    public ExecutorService createThreadPoolInstance() {
        //通过guava类库的ThreadFactoryBuilder来实现线程工厂类并设置线程名称
        ThreadFactory threadFactory = new ThreadFactoryBuilder().setNameFormat("thread-pool-%d").build();
        ExecutorService threadPool = new ThreadPoolExecutor(10, 16, 60L, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(100), threadFactory, new ThreadPoolExecutor.AbortPolicy());
        return threadPool;
    }
}

（2）引用线程池实例

（3）executorService.execute(new Runnable（）{}）；

  @Resource(name = "threadPoolInstance")
  private ExecutorService executorService;
 
  @Override
  public void spikeConsumer() {
    //TODO
    executorService.execute(new Runnable() {
    @Override
    public void run() {
      //TODO
     }});
}