(一)并发-线程的创建

一、线程的创建方式

线程的创建方式有继承Thread类、实现Runnable接口、实现Callable接口、FutureTask+Thread、线程池。

（1.1）继承Thread类

/**  
* @Author 尘心[ZcJ]  
* @Date [2023/4/26]-[10:08 PM]  
* @Desc 线程的创建方式 继承Thread类  
*/  
public class CreateThread01 {  
    public static void main(String[] args) {  
        new MyExtendsThread().start();
    }  
}  
  
class MyExtendsThread extends Thread{
    @Override  
    public void run() {  
    System.out.println("我是继承Thread类实现的线程");  
    }  
}
复制代码

（1.2）实现Runnable接口

/**  
* @Author 尘心[ZcJ]  
* @Date [2023/4/26]-[10:22 PM]  
* @Desc 创建线程的方式二 实现Runnable接口方式一 
*/  
public class CreateThread02 {  
    public static void main(String[] args) {  
        new Thread(new MyRunnableThread()).start();  
    }  
}  
  
class MyRunnableThread implements Runnable{  
    @Override  
    public void run() {  
        System.out.println("我是继承Runnable接口创建的线程");  
    }  
}
复制代码

/**  
* @Author 尘心[ZcJ]  
* @Date [2023/4/26]-[10:22 PM]  
* @Desc 创建线程的方式二 实现Runnable接口方式二
*/  
public class CreateThread02 {  
    public static void main(String[] args) {  
            new Thread(new Runnable() {  
                @Override  
                public void run() {  
                    System.out.println("我是实现Runnable接口匿名内部类实现的线程");  
                }  
            }).start();  
        }  
    }
复制代码

/**  
* @Author 尘心[ZcJ]  
* @Date [2023/4/26]-[10:22 PM]  
* @Desc 创建线程的方式二 实现Runnable接口方式三
*/  
public class CreateThread02 {  
    public static void main(String[] args) {  
        new Thread(() -> System.out.println("我是实现Runnable接口Lambda表达式实现的线程")).start();  
    }  
}
复制代码

（1.3）实现Callable接口

Callable接口实现的线程可以拥有返回值并且可以捕获抛出异常信息

/**  
* @Author 尘心[ZcJ]  
* @Date [2023/4/26]-[10:30 PM]  
* @Desc 创建线程的方式三 实现Callable接口方式一 
*/  
public class CreateThread03 {  
    public static void main(String[] args) throws ExecutionException, InterruptedException {  
        FutureTask<String> futureTask = new FutureTask<>(new Callable<String>() {  
                @Override  
                public String call() {  
                    return "我是实现Callable接口匿名内部类创建的线程";  
                }  
            });  
        new Thread(futureTask).start();  
        System.out.println(futureTask.get());  
        }  
}
复制代码

/**  
* @Author 尘心[ZcJ]  
* @Date [2023/4/26]-[10:30 PM]  
* @Desc 创建线程的方式三 实现Callable接口方式二
*/  
public class CreateThread03 {  
    public static void main(String[] args) throws ExecutionException, InterruptedException {  
        FutureTask<String> futureTask = new FutureTask<>(() -> "我是实现Callable接口lambda创建的线程");  
        new Thread(futureTask).start();  
        System.out.println(futureTask.get());  
    }  
}
复制代码

/**  
* @Author 尘心[ZcJ]  
* @Date [2023/4/26]-[10:30 PM]  
* @Desc 创建线程的方式三 实现Callable接口方式三
*/  
public class CreateThread03 {  
    public static void main(String[] args) throws ExecutionException, InterruptedException {  
        FutureTask<String> futureTask = new FutureTask<>(new MyCallableThread()); 
        new Thread(futureTask).start();  
        System.out.println(futureTask.get());  
    }  
}  
  
class MyCallableThread implements Callable<String>{  
    @Override  
    public String call() throws Exception {  
        return "我是实现Callable接口创建的线程";  
    }  
}
复制代码

（1.4）FutureTask+Thread

FutureTask继承Runnable接口

/**  
* @Author 尘心[ZcJ]  
* @Date [2023/4/26]-[10:30 PM]  
* @Desc 创建线程的方式四 FutureTask+Thread
*/  
public class CreateThread04 {  
    public static void main(String[] args) throws ExecutionException, InterruptedException {  
        FutureTask<String> futureTask = new FutureTask<>(() -> "我是使用FutureTask+Thread的lambda创建的线程");  
        new Thread(futureTask).start();  
        System.out.println(futureTask.get());  
    }  
}
复制代码

（1.5）使用线程池

通过以上四种方式创建的线程使用完毕会被回收释放，不能重复使用，而使用线程池创建的线程可以被缓存起来，方便调用节省创建线程所消耗的资源和时间。

(1.5.1) 使用Executors工具类

/**  
* @Author 尘心[ZcJ]  
* @Date [2023/4/26]-[11:08 PM]  
* @Desc 创建线程的方式五线程池 submit(Runnable var1) 方式一
*/  
public class CreateThread05 {  
    public static void main(String[] args) {  
    ExecutorService executorService = Executors.newCachedThreadPool();  
    executorService.submit(() -> {  
            System.out.println("使用线程池 ExecutorService.submit(Runnable var1)创建线程");  
        });  
    }  
}
复制代码

/**  
* @Author 尘心[ZcJ]  
* @Date [2023/4/26]-[11:08 PM]  
* @Desc 创建线程的方式五线程池 submit(Callable<T> var1) 方式二  
*/  
public class CreateThread05 {  
    public static void main(String[] args) throws ExecutionException, InterruptedException {  
        ExecutorService executorService = Executors.newCachedThreadPool();  
        Future<String> future = executorService.submit(() -> "使用线程池 ExecutorService.submit(Callable var1)创建线程");  
        System.out.println(future.get());  
    }  
}
复制代码

/**  
* @Author 尘心[ZcJ]  
* @Date [2023/4/26]-[11:08 PM]  
* @Desc 创建线程的方式五线程池 execute(Runnable var1) 方式三  
*/  
public class CreateThread05 {  
    public static void main(String[] args) {  
        ExecutorService executorService = Executors.newCachedThreadPool();  
        executorService.execute(() -> {  
            System.out.println( "使用线程池 ExecutorService.execute(Runnable var1)创建线程");  
        });  
    }  
}
复制代码

(1.5.2) 使用ThreadPoolExecutor工具类

/**  
* @Author 尘心[ZcJ]  
* @Date [2023/4/26]-[11:08 PM]  
* @Desc 使用线程池创建线程 submit(Runnable var1) 方式四（建议使用） 
* 调用方式同Executors类一致
*/  
public class CreateThread05 {  
    public static void main(String[] args) {  
        ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(1, 1, 20, TimeUnit.SECONDS, new ArrayBlockingQueue<>(10));  
        poolExecutor.submit(()-> {  
            System.out.println("我是使用ThreadPoolExecutor创建的线程");  
        });  
    }  
}