转载

Java创建线程的方式

Java创建线程主要有四种方式

1.继承Thread类

（1）创建线程类去继承Thread类

（2）重写Thread类的run方法，run方法中编写需要完成的任务

（3）创建线程类对象

（4）调用start方法启动线程

public class TestThread {
    public static void main(String[] args) {
        MyThread t = new MyThread();
        t.start();
    }
}
class MyThread extends Thread{
    //具体要完成的任务，打印1-10
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("自定义线程：" + i);
        }
    }
}

2.实现Runnable接口

（1）创建线程类实现Runnable接口

（2）线程类中实现Runnable接口的run方法

（3）通过Thread类创建线程对象。

（4）将Runnable接口的实现类对象作为实际参数传递给Thread类的构造器中。

（5）调用Thread类的start()方法启动线程

public class TestRunnable {
    public static void main(String[] args) {
        MyRunnable r = new MyRunnable();
        Thread t = new Thread(r);
        t.start();
        for (int i = 0; i < 100; i++) {
            System.out.println("main:"+i);
        }
    }
}
class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("自定义线程：" + i);
        }
    }
}

实现Runnable接口比继承Thread类创建线程的优势

避免了单继承带来的局限性

多个线程可以共享同一个接口实现类的对象，适合多个相同线程去处理同一个资源。

3.实现Callable接口

jdk5中新增创建线程的方式

（1）创建一个实现Callable接口的实现类

（2）实现call方法，设置此线程需要完成的任务

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

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

（5）将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，调用start方法

（6）可以获取call方法的返回值

public class TestCallable {
    public static void main(String[] args) {
         MyCallable c = new MyCallable();

        //创建FutureTask对象
        FutureTask<String> futureTask = new FutureTask<String>(c);

        //创建Thread对象，传入futureTask
        Thread t = new Thread(futureTask);
        t.start();

        //String s = futureTask.get(); //调用get方法可以获取call方法的返回值

        for (int i = 0; i<100; i++){
            System.out.println("main："+i);
        }
    }
}
class MyCallable implements Callable{
    @Override
    public String call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println("Callable线程:" + i);
        }
        return "MyCallable";
    }
}

Runnable和Callable的区别

相同点：

两种都需要调用Thread.start()来启动线程

不同点：

Runnable接口的run()方法没有返回值。

Callable的call()方法有返回值，是一个泛型，可以使用FutureTask类获取返回结果，并且可以抛出异常

4.使用线程池

Executors：工具类，用于创建并返回不同类型的线程池

ExecutorService：真正的线程池接口，常见子类ThreadPoolExecutor

public class TestPool {
    public static void main(String[] args) {

        //提供指定线程数量的线程池
        ExecutorService executorService = Executors.newFixedThreadPool(10);

        ThreadPoolExecutor executorService1 = (ThreadPoolExecutor)executorService;
        //设置参数
        //executorService1.setCorePoolSize();
        //executorService1.setKeepAliveTime();
        
        //执行线程操作，需要提供实现Runnable接口或Callable接口实现类的对象
        executorService.execute(new MyRunnable()); //适用于Runnable
        //executorService.submit(); //适用于Callable

        //关闭连接池
        executorService.shutdown();
    }
}
class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("MyRunnable线程：" + i);
        }
    }
}

原文 https://www.maiyewang.com/archives/91900

正文到此结束