Java 多线程（二）创建多线程的方式

创建线程

JDK1.5之前创建线程方式：

• 继承Thread类的方式
• 实现Runnable接口的方式

JDK5.0新增线程创建方式

• 实现Callable接口
• 使用线程池

继承Thread类的方式

1. 定义子类继承Thread类。
2. 子类中重写Thread类中的run方法。
3. 创建Thread子类对象，即创建了线程对象。
4. 调用线程对象start方法：启动线程，调用run方法。

代码实现

/**
 * 创建一个子线程，完成1-100之间自然数的输出。同样地，主线程执行同样的操作
 * 创建多线程的第一种方式：继承java.lang.Thread类
 * 1.创建一个继承于Thread的子类
 */
class SubThread extends Thread {
    /**
     * 2.重写Thread类的run()方法.方法内实现此子线程要完成的功能
     */
    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }
    }
}

public class TestThread1 {
    
    public static void main(String[] args) {
        //3.创建子类的对象
        SubThread st1 = new SubThread();
        SubThread st2 = new SubThread();

        //4.调用线程的start()：启动此线程；调用相应的run()方法
        //一个线程只能够执行一次start()
        //不能通过Thread实现类对象的run()去启动一个线程
        st1.start();
        st2.start();
        for (int i = 1; i <= 100; i++) {
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }
    }
}

注意事项：

• 如果自己手动调用run()方法，那么就只是普通方法，没有启动多线程模式。
• run()方法由JVM调用，什么时候调用，执行的过程控制都有操作系统的CPU调度决定。
• 想要启动多线程，必须调用start方法。
• 一个线程对象只能调用一次start()方法启动，如果重复调用了，则将抛出以上的异常“IllegalThreadStateException”。

实现Runnable接口的方式

1. 定义子类，实现Runnable接口。
2. 子类中重写Runnable接口中的run方法。
3. 通过Thread类含参构造器创建线程对象。
4. 将Runnable接口的子类对象作为实际参数传递给Thread类的构造器中。
5. 调用Thread类的start方法：开启线程，调用Runnable子类接口的run方法。

代码实现

/**
 * 创建多线程的方式二：通过实现的方式
 * 1.创建一个实现了Runnable接口的类
 */
class PrintNum1 implements Runnable {
    //2.实现接口的抽象方法
    @Override
    public void run() {
        // 子线程执行的代码
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

public class TestThread2 {
    
    public static void main(String[] args) {
        // 3.创建一个Runnable接口实现类的对象
        PrintNum1 p = new PrintNum1();
        // 要想启动一个多线程，必须调用start()
        // 4.将此对象作为形参传递给Thread类的构造器中，创建Thread类的对象，此对象即为一个线程
        Thread t1 = new Thread(p);
        // 5.调用start()方法：启动线程并执行run()
        // 启动线程；执行Thread对象生成时构造器形参的对象的run()方法。
        t1.start();

        //再创建一个线程
        Thread t2 = new Thread(p);
        t2.start();
    }
}

介绍了两种创建线程的方式，我们来对下继承方式和实现方式的联系与区别
区别：

• 继承Thread：线程代码存放Thread子类run方法中。
• 实现Runnable：线程代码存在接口的子类的run方法。

实现方式的好处

• 避免了单继承的局限性
• 多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处理同一份资源。

实现Callable接口的方式

与使用Runnable相比， Callable功能更强大些

• 相比run()方法，可以有返回值
• 方法可以抛出异常
• 支持泛型的返回值
• 需要借助FutureTask类，比如获取返回结果

Future接口

• 可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等；
• FutrueTask是Futrue接口的唯一的实现类；
• FutureTask 同时实现了Runnable, Future接口。它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值。

测试代码

/**
 * 一、创建执行线程的方式三：实现 Callable 接口。 相较于实现 Runnable 接口的方式，支持泛型，方法可以有返回值，并且可以抛出异常。
 * 
 * 二、执行 Callable 方式，需要 FutureTask 实现类的支持，用于接收运算结果。  FutureTask 是  Future 接口的实现类
 */
public class TestCallable {
	
	public static void main(String[] args) {
		ThreadDemo td = new ThreadDemo();
		
		//1.执行 Callable 方式，需要 FutureTask 实现类的支持，用于接收运算结果。
		FutureTask<Integer> result = new FutureTask<>(td);
		
		new Thread(result).start();
		
		//2.接收线程运算后的结果
		try {
			Integer sum = result.get();  //FutureTask 可用于 闭锁
			System.out.println(sum);
			System.out.println("------------------------------------");
		} catch (InterruptedException | ExecutionException e) {
			e.printStackTrace();
		}
	}

}

class ThreadDemo implements Callable<Integer>{

	@Override
	public Integer call() throws Exception {
		int sum = 0;
		
		for (int i = 0; i <= 100000; i++) {
			sum += i;
		}
		
		return sum;
	}
	
}

使用线程池方式

为啥要使用线程池的方式创建线程？

1. 经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。
2. 提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。
3. 提高响应速度（减少了创建新线程的时间）
4. 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
5. 便于线程管理
   corePoolSize：核心池的大小
   maximumPoolSize：最大线程数
   keepAliveTime：线程没有任务时最多保持多长时间后会终止
   等等

线程池相关API

JDK 5.0起提供了线程池相关API：ExecutorService 和 Executors

• ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor
  void execute(Runnable command) ：执行任务/命令，没有返回值，一般用来执行Runnable
  <T> Future<T> submit(Callable<T> task)：执行任务，有返回值，一般又来执行Callable
  void shutdown() ：关闭连接池
• Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池
  Executors.newCachedThreadPool()：创建一个可根据需要创建新线程的线程池
  Executors.newFixedThreadPool(n)：创建一个可重用固定线程数的线程池
  Executors.newSingleThreadExecutor() ：创建一个只有一个线程的线程池
  Executors.newScheduledThreadPool(n)：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行

代码示例：

/**
 * 创建线程的方式四：使用线程池
 * <p>
 * 好处：
 * 1.提高响应速度（减少了创建新线程的时间）
 * 2.降低资源消耗（重复利用线程池中线程，不需要每次都创建）
 * 3.便于线程管理
 * corePoolSize：核心池的大小
 * maximumPoolSize：最大线程数
 * keepAliveTime：线程没有任务时最多保持多长时间后会终止
 * <p>
 * <p>
 * 面试题：创建多线程有几种方式？四种！
 */

class NumberThread1 implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        }
    }
}

class NumberThread2 implements Callable {
    //2.实现call方法，将此线程需要执行的操作声明在call()中
    @Override
    public Object call() {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            if(i % 2 != 0){
                System.out.println(Thread.currentThread().getName() + ": " + i);
                sum += i;
            }
        }
        return sum;
    }
}

public class ThreadPool {

    public static void main(String[] args) {
        //1. 提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
        // ThreadPoolExecutor 实现类可以设置线程池的属性
//        System.out.println(service.getClass());
//        service1.setCorePoolSize(15);
//        service1.setKeepAliveTime();


        //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumberThread1());//适合适用于Runnable
        service.submit(new NumberThread2());//适合适用于Callable

        //3.关闭连接池
        service.shutdown();
    }

}