多线程的四种创建方式

1.创建方式一：继承Thread类

package com.cjj.duoxiancheng;

/*
* 路人假helloWorld
* 多线程的创建，方式一：继承Thread类
*   1.创建一个继承于Thread类的子类
*   2.重写Thread类的run()方法  --> 将此线程的操作声明在run()中
*   3.创建Thread类的子类对象
*   4.通过此对象调用start()
* 例子：遍历输出100以内的所有偶数。
* */

class MyThread extends Thread{
    //重写run()方法
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            if (i % 2 == 0){
                System.out.println(i);
            }
        }
    }
}

public class ThreadTest {
    public static void main(String[] args) {
        //创建Thread类的子类对象
        MyThread p = new MyThread();

        p.start();
        for (int i = 0; i <= 100; i++) {
            System.out.println("===main线程=====" + i);
        }

    }
}

2.创建方式二：实现Runnable接口

package com.cjj.duoxiancheng;

/*
* 路人假helloWorld
* 多线程的创建方式二：实现Runnable接口
* 1.创建一个实现了Runnable接口的类
* 2.实现类去实现Runnable中的抽象方法：run()
* 3.创建实现类的对象
* 4.将此对象作为参数传递到Thread类的构造器当中，创建Thread类的对象
* 5.通过Thread类的对象调用start()
* */

//1.创建一个实现了Runnable接口的类
class MThread implements Runnable{

    //2.实现类去实现Runnable中的抽象方法：run()
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}

public class ThreadTest1 {
    public static void main(String[] args) {
        //3.创建实现类的对象
        MThread myThread = new MThread();

        //4.将此对象作为参数传递到Thread类的构造器当中，创建Thread类的对象
        Thread t1 = new Thread(myThread);

        //5.通过Thread类的对象调用start()
        t1.start();

        Thread t2 = new Thread(myThread);
        t2.start();
    }


}

3.创建方式三：实现Callable接口

/*
* 路人假helloWorld
* 创建线程的方式三：实现Callable接口 --> JDK5.0 新增
*
* 如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式更强大？
* 1.call()方法可以有返回值
* 2.call()方法可以抛出异常，被外面的操作捕获，获取异常的信息
* 3.Callable是支持泛型的
* */

class NumThread implements Callable {

    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 0; i <= 100; i++) {
            if (i % 2 == 0){
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}

public class ThreadCallable {

    public static void main(String[] args) {
        //创建Callable接口实现类对象
        NumThread numThread = new NumThread();
        //将Callable接口实现类对象传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask futureTask = new FutureTask(numThread);
        //将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()方法
        new Thread(futureTask).start();

        try {
            //获取Callable中call方法的返回值
            //get()返 回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
            Object sum = futureTask.get();
            System.out.println("总和为：" + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }

}

4.创建方式四：使用线程池

/*
*路人假helloWorld
*/
class NumThread1 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 NumThread2 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            if(i % 2 != 0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}

public class ThreadPool {
    public static void main(String[] args) {
        //提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);

        //可以设置线程池的属性
        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
        service1.setCorePoolSize(15);

        //执行指定的线程操作
        service.execute(new NumThread1()); //适用于实现Runnable接口
        service.execute(new NumThread2()); //适用于实现Runnable接口
        //service.submit(Callable callable);  //适用于实现Callable接口

        //关闭线程池
        service.shutdown();
    }
}