Java.多线程四种创建方式

方式一: 继承Thread类

实现步骤:
	1 单独定义一个类,(如ThreadTest类),让ThreadTest继承Thread;
	2 从Thread类中继承而来的run()方法进行重写,把线程要做的事情定义在run()里面,
		run()方法内的语句,称为线程执行体;
	3 创建子类对象(ThreadTest) -> 创建线程对象;
	4 使用创建的子类对象调用start()方法,启动线程;
	这里启动线程的机制需要注意:
		- 调用的start()方法为父类中的方法,由父类(Thread)启动线程,
		  JVM虚拟机后台调用run()方法,因为子类(ThreadTest)重写run(),
		  最终调用的就是子类中重写的run()方法;(多态)

代码示例: 

// 1 定义子类继承Thread
class ThreadTest extends Thread{
	// 2 重写父类中的run()方法
	public void run(){
		// 线程语句执行体
	}
}

public class MyThread {
	public static void main(String[] args){
		// 3 创建子类对象
		ThreadTest t1 = new ThreadTest();
		// 4 启动线程
		t1.start();
	}
}

方式二: 实现Runnable接口

实现步骤: 
	1、定义一个类实现Runnable接口;
	2、实现接口中run()抽象方法,把线程要做的事情定义在run()里面,
		run()方法内的语句,称为线程执行体;
	3、创建该类实例化对象;
	4、调用Thread类的有参构造器,把实现类对象作为参数传递进去,得到一个线程对象;
	5、通过线程对象调用start(): ① 启动线程 ② 调用run().

代码示例: 

// 1 定义一个类实现Runnable接口
class ThreadTest implements Runnable{
	// 2 实现接口中的run()抽象方法
	public void run(){
		// 线程语句执行体
	}
}

public class MyThread {
	public static void main(String[] args){
		// 3 创建实例化对象
		ThreadTest t1 = new ThreadTest();
		// 4 调用Thread类的有参构造器,把实现类对象作为参数传递进去,得到一个线程对象;
		Thread t2 = new Thread(t1);
		// 5 启动线程
		t2.start();
	}
}

方式三: 使用Callable接口创建线程

实现步骤:
	1 定义实现类实现Callable接口;
	2 实现接口中定义的call(),对于线程要做的事情写在call()方法中;
	3 创建Callable接口的实现类对象;
	4 将Callable实现类的对象,使用FutureTask类来包装;
	5 此FutureTask对象作为Thread对象的target来创建线程;
	6 使用Thread对象调用start()方法,启动线程;
	7 对于实现Callable接口的类,该call()方法具有返回值,这里可以使用FutureTask对象调用get()方法获取返回值;

代码示例: 

// 1 定义实现类实现Callable接口
class MyCallable implements Callable {
	// 2 实现该抽象方法,需要执行的代码写在方法内
    public Integer call() {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
            sum += i;
        }
        return sum;
    }
}

public class ThreadTest {
    public static void main(String[] args) {
    	// 3 创建Callable接口的实现类对象
        Callable myCallable = new MyCallable();
        // 4 FutureTask类来包装步骤3中创建的对象
        FutureTask ft = new FutureTask(myCallable);
        // 5 将FutureTask对象作为Thread对象的target来创建线程
        Thread thread = new Thread(ft);
        // 6 启动线程
        thread.start();
        int sum = 0;
        try {
        	// 7 通过FutureTask对象调用get()方法获取返回值
        	// 此处异常需要处理
            sum = ft.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println("sum = " + sum);
    }
}

方式四: 使用线程池创建线程

代码示例: (线程池这里不做赘述,后续讲)

public class ThreadPoolTest {
    public static void main(String[] args) {
        ExecutorService threadPool = Executors.newFixedThreadPool(5);
        for(int i = 1; i <= 20; i++){
            threadPool.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + " : 开始执行任务");
                }
            });
        }
        threadPool.shutdown();
    }
}