Java 多线程(二)创建多线程的方式

逆流者 2020年08月04日 39次浏览

创建线程

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:ExecutorServiceExecutors

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

}