java 多线程学习记录

一.多线程几种基本的实现方式

JAVA多线程实现方式主要有三种：继承Thread类、实现Runnable接口、使用ExecutorService、Callable、Future实现有返回结果的多线程。其中前两种方式线程执行完后都没有返回值，只有最后一种是带返回值的。

1、继承Thread类实现多线程

继承Thread类的方法尽管被我列为一种多线程实现方式，但Thread本质上也是实现了Runnable接口的一个实例，它代表一个线程的实例，并且，启动线程的唯一方法就是通过Thread类的start()实例方法。start()方法是一个native方法，它将启动一个新线程，并执行run()方法。这种方式实现多线程很简单，通过自己的类直接extend Thread，并复写run()方法，就可以启动新线程并执行自己定义的run()方法。例如：

public class MyThread extends Thread {
　　public void run() {
　　 System.out.println("MyThread.run()");
　　}
}

 在合适的地方启动线程如下：

MyThread myThread1 = new MyThread();
MyThread myThread2 = new MyThread();
myThread1.start();
myThread2.start();

这种也可以用匿名内部类的方法实现：

new Thread(() -> System.out.println("MyThread.run()")).start();

 这种方式我之前没用过，当时我在网上看到这句代码，就在疑惑，为什么它能直接识别实现的是run方法，后来在网上看到

虽然使用 Lambda 表达式可以对某些接口进行简单的实现，但并不是所有的接口都可以使用 Lambda 表达式来实现。Lambda 规定接口中只能有一个需要被实现的方法，不是规定接口中只能有一个方法

才理解了，相关大神文章地址： https://www.cnblogs.com/haixiang/p/11029639.html

 2、实现Runnable接口方式实现多线程

如果自己的类已经extends另一个类，就无法直接extends Thread，此时，必须实现一个Runnable接口，如下：

public class MyThread extends OtherClass implements Runnable {
　　public void run() {
　　 System.out.println("MyThread.run()");
　　}
}

为了启动MyThread，需要首先实例化一个Thread，并传入自己的MyThread实例：

MyThread myThread = new MyThread();
Thread thread = new Thread(myThread);
thread.start();

事实上，当传入一个Runnable target参数给Thread后，Thread的run()方法就会调用target.run()，参考JDK源代码：

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

 3、使用Callable、FutureTask实现有返回结果的多线程

实现Callable接口，并用其初始化Thread，然后创建Thread实例，并调用start方法（下面实例可将Lambda表达式展开使用；也可将FutureTask换为Future对象，去实现，原理是一样的，具体方法可百度；可利用FutureTask获取多线程执行的结果，并且可以限定超时时间，文章后面会有相关拓展）

//创建MyThread实例
Callable<String> c = () -> {
	System.out.println(Thread.currentThread().getName());
	return "执行成功";
};
//获取FutureTask
FutureTask<String> ft = new FutureTask(c);
//使用FutureTask初始化Thread
Thread t = new Thread(ft);
//输出：
//Thread-0 Thread-1
t.start();

 总结：以上三种方式其实都是以实现run接口为手段启动的

拓展：获取多线程任务执行的结果，设置超时时间

	public static void main(String[] args) {
		Callable ca1 = () -> {int x = 0,y=0;
			x++;
			try {
				Thread.sleep(1000*6);
				System.out.println("处理正常");
				return "处理正常";
			} catch (InterruptedException e) {
				System.out.println("线程已被中断");
				//e.printStackTrace();
			}
			y++;
			System.out.println(x+","+y);
			return "结束";
		};
		FutureTask<String> ft1 = new FutureTask<String>(ca1);
		new Thread(ft1).start();
		try {
			String s= ft1.get(1000, TimeUnit.MILLISECONDS);
		}catch (TimeoutException e){
			System.out.println("超时，中断任务");
			ft1.cancel(true);//停止任务
		}catch (Exception es){
			es.printStackTrace();//其他报错信息
		}
	}

 上面的 ft1.get(1000, TimeUnit.MILLISECONDS); 也可直接用ft1.get();获取最终结果，前面的方法是限定了超时时间。

注意：多线程执行任务被打断时，还是会将代码执行完的，比如上面被中断后（包括thread.interrupt方法可以中断，以及ft1.get(1000, TimeUnit.MILLISECONDS)超时后也会中断）还是会计算y++并打印，所以建议把业务放在try代码块中执行，在后面catch到InterruptedException，进行被打断的后续处理，或者在new Thread(ft1).start();等其他地方catch进行处理操作。

二.以上几种方式的弊端，以及处理方法

1.new Thread的弊端：

a. 每次new Thread新建对象性能差。
b. 线程缺乏统一管理，可能无限制新建线程，相互之间竞争，及可能占用过多系统资源导致死机或oom。
c. 缺乏更多功能，如定时执行、定期执行、线程中断。
相比new Thread，Java提供的四种线程池的好处在于：
a. 重用存在的线程，减少对象创建、消亡的开销，性能佳。
b. 可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免堵塞。
c. 提供定时执行、定期执行、单线程、并发数控制等功能。

2.Executors提供四种线程池

newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。线程池的规模不存在限制。
newFixedThreadPool 创建一个固定长度线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newScheduledThreadPool 创建一个固定长度线程池，支持定时及周期性任务执行。
newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

 下面代码说明：

(1). newCachedThreadPool
创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。示例代码如下：

ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
for (int i = 0; i < 10; i++) {
    final int index = i;
    try {
        Thread.sleep(index * 1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
  
    cachedThreadPool.execute(new Runnable() {
  
        @Override
        public void run() {
            System.out.println(index);
        }
    });
}

 线程池为无限大，当执行第二个任务时第一个任务已经完成，会复用执行第一个任务的线程，而不用每次新建线程。

(2). newFixedThreadPool
创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。示例代码如下：

ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
for (int i = 0; i < 10; i++) {
    final int index = i;
    fixedThreadPool.execute(new Runnable() {
  
        @Override
        public void run() {
            try {
                System.out.println(index);
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    });
}

 因为线程池大小为3，每个任务输出index后sleep 2秒，所以每两秒打印3个数字。

 定长线程池的大小最好根据系统资源进行设置。

(3) newScheduledThreadPool
创建一个定长线程池，支持定时及周期性任务执行。延迟执行示例代码如下：

ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
scheduledThreadPool.schedule(new Runnable() {
  
    @Override
    public void run() {
        System.out.println("delay 3 seconds");
    }
}, 3, TimeUnit.SECONDS);

表示延迟3秒执行。

定期执行示例代码如下：

scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
  
    @Override
    public void run() {
        System.out.println("delay 1 seconds, and excute every 3 seconds");
    }
}, 1, 3, TimeUnit.SECONDS);

表示延迟1秒后每3秒执行一次。

ScheduledExecutorService比Timer更安全，功能更强大。

(4)、newSingleThreadExecutor
创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。示例代码如下：

ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
for (int i = 0; i < 10; i++) {
    final int index = i;
    singleThreadExecutor.execute(new Runnable() {
  
        @Override
        public void run() {
            try {
                System.out.println(index);
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    });
}

 结果依次输出，相当于顺序执行各个任务。