1、实现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 mThread = new MThread();
        //4、将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
        Thread t1 = new Thread(mThread);
        //5、通过Thread类的对象调用start():启动线程;调用当前线程的run()-->调用了Runnable类型的target的run()
        t1.start();


        //在启动一个线程,遍历100以内的偶数
        Thread t2 = new Thread(mThread);
        t2.start();
    }
}

2、继承Thread类

1、创建一个继承于Thread类的子类
2、重写Thread类的run()–>将此线程执行的操作声明到run()中
3、创建Thread类的子类对象
4、通过此对象调用start()

//1、创建一个继承于Thread类的子类
class MyThread extends Thread
{
    //2、重写Thread类的run()-->将此线程执行的操作声明到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 ThreadTest {
    public static void main(String[] args) {
        //3、创建Thread类的子类对象
        MyThread t1=new MyThread();
        //4、通过此对象调用start():启动当前线程；调用当前线程的run()
        t1.start();
        System.out.println(Thread.currentThread().getName()+":"+"HEllo");
    }
}

3、实现Callable接口

1、创建一个实现Callable接口的实现类
2、实现call(),将此线程需要执行的操作名声在call()中，call()可以有返回值
3、创建Callable接口实现类的对象
4、将此Callable实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask对象
5、将FutureTask对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
6、如果有返回值，调用get()方法，即为FutureTask构造器参数Callable实现类重写的call()的返回值

//1、创建一个实现Callable的实现类
class NumThread implements Callable{
    //2、实现call方法,将此线程需要执行的操作声明在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;
    }
}

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

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

4、线程池

1、提供指定数量线程的线程池
2、执行指定线程的操作，需要提供实现Runnable接口或Callable接口的实现类对象
3、关闭连接池

class NumberThread 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) {
        //1、提供指定数量线程的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor executor=(ThreadPoolExecutor)service;
        //设置线程池的属性
        executor.setCorePoolSize(15);
        //2、执行指定线程的操作，需要提供实现Runnable接口或Callable接口的实现类对象
        service.execute(new NumberThread());//适合适用于Runnable
        //3、关闭连接池
        service.shutdown();
    }
}

5、优略对比：

1、继承Thread类 Vs 实现Runnable/Callable接口

因为java 是仅仅支持单继承，而且需要实现多线程的类往往都有属于自己的父类，所以继承Thread类的方式稍微差一点。

2、实现Runnable接口 Vs 实现Callable接口

(1)、实现Callable接口，重写的call()可以有返回值，但是实现Runnable接口，重写的run()没有返回值。
(2)、实现Callable接口，重写的call()可以抛出异常，被外面的操作捕获，获得异常信息。但是实现Runnable接口，重写的run()不能做到
(3)、实现Callable接口，支持泛型。

实现Callable接口 Vs线程池

(1)、提高相应速度(减少创建新线程所消耗的时间)
(2)、降低资源消耗(重复利用线程池中的线程，不需要每次都创建线程，每次都销毁线程)
(3)、可以对线程池中的线程进行管理。

齐智

原创文章 86 获赞 50 访问量 4万+

关注私信

java多线程的四种方式