JUC之创建线程的四种方式

一、继承Thread类

通过自定义类继承Thread类来创建

class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "----" + i);
        }
    }
}

public class ThreadDemo {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName() + " === main");
        MyThread myThread = new MyThread();
        myThread.start();
    }
}

二、实现Runable接口

1. 通过自定义类实现Runable接口来创建

class MyThread implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "----" + i);
        }
    }
}

public class ThreadDemo {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName() + " === main");
        Thread thread = new Thread(new MyThread());
        thread.start();
    }
}

2. 使用匿名内部类来是实现

public class ThreadDemo {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName() + " === main");
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println(Thread.currentThread().getName() + "----" + i);
                }
            }
        });
        thread.start();
    }
}

3. 使用lambda表达式来创建

public class ThreadDemo {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName() + " === main");
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + "----" + i);
            }
        },"My Thread").start();
    }
}

三、实现Callable接口

通过Callable来创建线程，可以有返回值

1. 自定义类实现Collable接口

class MyThread implements Callable<String> {
    @Override
    public String call() throws Exception {
        System.out.println(Thread.currentThread().getName());
        return "hello world";
    }
}

public class ThreadDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask futureTask = new FutureTask(new MyThread());
        Thread thread = new Thread(futureTask);
        thread.start();
        // 获取返回值
        System.out.println(futureTask.get());
    }
}

• 对于同一个FutureTask，不管你通过它创建多少个线程，返回值结果都是一样的。

2. Runbale与Callable的区别

• Callable实现的方法是call(),Runnable实现的方法是run().
• Callable的任务执行后有返回值，而Runnable的任务没有返回值
• call方法可以抛出异常，run方法不可以
• 运行Callable任务可以拿到一个Future对象，表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。通过Future对象可以了解任务执行情况，可取消任务的执行，还可获取执行结果。

四、线程池

newFixedThreadPool

线程的数量有自己指定

public class ThreadDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 10; i++) {
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println("线程 " + Thread.currentThread().getName() + " 被调用了");
                }
            });
        }
        executorService.shutdown();
    }
}

newSingleThreadExecutor

只有一个线程

public class ThreadDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println("线程 " + Thread.currentThread().getName() + " 被调用了");
                }
            });
        }
        executorService.shutdown();
    }
}

newCachedThread

根据任务多少来自动实现线程数的增减

public class ThreadDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println("线程 " + Thread.currentThread().getName() + " 被调用了");
                }
            });
        }
        executorService.shutdown();
    }
}