java创建多线程的四种方式

先理解三个问题：

​ 1.什么是多线程？

答：程序（program）是一段静态的代码，而进程（process）是正在运行的一个程序，而线程（thread）是进程的一条执行路径。多线程就是进程同时运行多条执行路径。

​ 2.为什么要使用多线程？

答：为了解决负载均衡问题,充分利用CPU资源；为了提高CPU的使用率,采用多线程的方式去同时完成几件事情而不互相干扰；为了处理大量的IO操作时或处理的情况需要花费大量的时间等等,比如:读写文件,视频图像的采集,处理,显示,保存等。

​ 3.怎么创建和使用多线程？

答：引出下面要说的重点：创建多线程的四种方式如下：

一、继承Thread类

1. 创建一个继承于Thread类的子类

2. 重写Thread类的run() 方法---- 将此线程执行的操作声明在run()中

3. 创建Thread类的子类的对象

4. 通过此对象调用start()：①启动当前线程 ② 调用当前线程的run()

代码示例：

//1.创建一个类继承于Thread类
class Demo extends Thread {
    //2.重写Thread类中的run方法，并将线程要执行的操作声明在run方法中
    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            System.out.println("我是创建的线程");
        }
    }
}
//测试类：
public class ThreadTest {
    public static void main(String[] args) {
        //3.实例化Thread类的子类对象
        Demo d1 = new Demo();
        //4.通过此对象调用start()方法;start方法的作用:①启动当前线程 ②调用当前线程的run()方法
        d1.start();

        //为了展示多线程效果,我们在main主线程中也遍历输出一下作为对比
        for (int i = 0; i < 3; i++) {
            System.out.println("我是主线程");
        }
    }
}

输出结果:

二、实现Runnable接口

1. 创建一个实现了Runnable接口的类

2. 实现类去实现(重写)Runnable中的抽象方法：run()

3. 创建实现类的对象

4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象

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

代码示例:

//1.创建一个实现了Runnable接口的类
class Demo implements Runnable {
    //2.实现类去实现(重写)Runnable中的抽象方法：run()
    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            System.out.println("我是创建的线程");
        }
    }
}

//测试类:
class ThreadTest {
    public static void main(String[] args) {
//3.创建实现类的对象
        Demo d1 = new Demo();
//4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
        Thread thread = new Thread(d1);
//5.通过Thread类的对象调用start()
        thread.start();

        //同样为了展示多线程效果,我们在main主线程中也遍历输出一下作为对比
        for (int i = 0; i < 3; i++) {
            System.out.println("我是主线程");
        }
    }
}

输出结果同上面一样

继承Thread类的方式与实现Runnable接口方式对比：

开发中：优先选择：实现Runnable接口的方式

原因：1. 实现的方式没类的单继承性的局限性

​ 2. 实现的方式更适合来处理多个线程共享数据的情况

联系：查看源码发现Thread类实现了Runnable接口

​ public class Thread implements Runnable

相同点：两种方式都需要重写run(),将线程要执行的逻辑声明在run()中。
目前两种方式，要想启动线程，都是调用的Thread类中的start()。

三、实现Callable接口

1.创建一个实现了Callable接口的类

2.实现(重写)call方法，将此线程需要执行的操作声明在call()中

3.创建Callable接口实现类的对象

4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象

5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()

6.获取Callable中call方法的返回值

代码示例:

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

//1.创建一个实现了Callable接口的类
class Demo implements Callable { //Callable接口有泛型我们这里先不写默认Object
    //2.实现(重写)call方法，将此线程需要执行的操作声明在call()中
    @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;
    }
}
//测试:
class Test {
    public static void main(String[] args) {
        //3.创建Callable接口实现类的对象
        Demo d1 = new Demo();
        //4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask futureTask = new FutureTask(d1);
        //5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
        new Thread(futureTask).start();
        //6.获取Callable中call方法的返回值
        try {
            //这里应为我们没有用泛型默认的是Object类型
            //int型的sum自动装箱成Integer类型然后向上转型成Object类型
            Object sum = futureTask.get();//get方法要处理异常
            System.out.println("总和为:" + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

输出结果:

实现Callable接口的方式相对于实现Runnable接口的方式的优点:

1. call()可以返回值的。

2. call()可以抛出异常，被外面的操作捕获，获取异常的信息

3. Callable是支持泛型的

四、使用线程池

1.什么是线程池?

答: 用来存放线程的一个容器

2.为什么要用线程池(好处)?

答: 线程池做的工作主要是控制运行的线程的数量，处理过程中将任务加入队列，然后在线程创建后启动这些任务，如果线程超过了最大数量，超出的数量的线程排队等候，等其他线程执行完毕，再从队列中取出任务来执行。

好处:

​ ①提高响应速度（减少了创建新线程的时间）

​ ②降低资源消耗（重复利用线程池中线程，不需要每次都创建）

​ ③便于线程管理

3.怎么使用线程池?

​ ①提供指定线程数量的线程池

​ ②执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象

​ ③关闭连接池

代码示例:

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;


class NumberThread implements Runnable{

    @Override
    public void run() {
        //遍历100以内的偶数
        for (int i = 0; i <= 100; i++) {
            if (i%2==0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}
class NumberThread1 implements Callable{

    @Override
    public Object call() throws Exception {
        //遍历100以内的奇数
        for (int i = 0; i <=100 ; i++) {
            if (i%2!=0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
        return null;
    }
}

public class Test {
    public static void main(String[] args) {
//1. 提供指定线程数量的线程池
        ExecutorService pool = Executors.newFixedThreadPool(10);//设置10个线程
//2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
        //我们在上面创建两个线程一个实现Runnable,一个实现Callable
        pool.execute(new NumberThread());//用于Runnable
        pool.submit(new NumberThread1());//用于Callable

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

输出结果:

过年了也不能松懈 ! 继续加油~! 冲冲冲!!!