如何创建线程对象？

什么是线程？

线程（Thread）是计算机科学中的基本概念，它表示程序执行流的最小单元。简单来说，一个线程就是程序中一个单独的执行路径。在多线程编程中，一个进程可以拥有多个并发执行的线程，每个线程都独立运行，但又共享相同的内存空间和资源。

为什么要有线程？

并发执行：线程使得程序可以并发执行多个任务，每个任务可以独立运行，互不干扰。可以提高程序的效率和响应速度，特别是在需要处理多任务、响应用户输入或处理多种输入输出时非常有用。

资源共享：线程在同一个进程内部共享相同的内存空间和资源。这使得不同线程可以更容易地共享数据和通信，而无需使用复杂的进程间通信（IPC）机制。

提高程序设计的灵活性：使用线程可以将程序结构分解为多个逻辑上独立的部分，每个部分可以独立地处理不同的任务。这种模块化的设计可以提高代码的可维护性和扩展性。

资源利用率：线程可以更有效地利用计算机的多核处理器和多任务操作系统的优势。通过多线程并行执行任务，可以充分利用系统的硬件资源，提高整体性能。

响应性：在用户界面编程中，使用线程可以使得程序能够同时处理用户输入和其他后台任务，保持界面的流畅性和响应性。

线程的创建方式有哪些？

1. 继承 Thread 类：

   • 定义一个类继承自 java.lang.Thread 类。

   • 重写 run() 方法，该方法包含了线程的主要逻辑。

   • 创建该类的实例，并调用 start() 方法启动线程。

   public class MyThread extends Thread{
       @Override
       public void run(){
           for (int i = 0; i < 20; i++) {
               System.out.println("线程执行中");
           }
       }
   }
   

       public static void main(String[] args) {
           MyThread myThread = new MyThread();
           //启动线程
           myThread.start();
           //主线程继续向下执行，跟线程并行执行
           //输出结果是穿插执行的
           for (int i = 0; i < 30; i++) {
               System.out.println("我是主线程1111111111111111111111");
           }
       }

2. 实现 Runnable 接口：

   • 定义一个类实现 java.lang.Runnable 接口，并实现其 run() 方法。

   • 创建一个 Thread 对象，将 Runnable 对象作为参数传递给 Thread 的构造函数。

   • 调用 Thread 对象的 start() 方法启动线程。

   class MyRunnable implements Runnable {
       public void run() {
           // 线程执行的逻辑
       }
   }

    public static void main(String[] args) {
           ThreadRunnable threadRunnable = new ThreadRunnable();
   //        threadRunnable.run();
           //没有start方法
           Thread thread = new Thread(threadRunnable);
           thread.start();
           for (int i = 0; i < 100; i++) {
               System.out.println("111111111111111111111");
           }
       }

   如果MyRunnable 接口只用一次，可以不用创建MyRunnable 接口，直接通过匿名内部类或者lambda表达式简写。

   //匿名内部类
   new Thread(new Runnable() {
               @Override
               public void run() {
                   System.out.println("-------");
               }
           }).start();
   //或者
   Thread thread = new Thread(new Runnable() {
               @Override
               public void run() {
                   System.out.println("-------");
               }
           });
   thread.start();

   //lambda表达式
   new Thread(()->System.out.println("-------")).start();
   
   //或者
   Thread thread = new Thread(()->System.out.println("-------"));
   thread.start();

   匿名内部类和lambda表达式
   https://blog.csdn.net/weixin_64618449/article/details/140831926?spm=1001.2014.3001.5501https://blog.csdn.net/weixin_64618449/article/details/140831926?spm=1001.2014.3001.5501

3. 实现 Callable 接口（Java 5 引入）：

   • 定义一个类实现 java.util.concurrent.Callable 接口，并实现其 call() 方法，该方法可以返回一个结果。

   • 创建 java.util.concurrent.FutureTask 对象，将 Callable 对象作为参数传递给 FutureTask 的构造函数。

   • 创建一个 Thread 对象，将 FutureTask 对象作为参数传递给 Thread 的构造函数。

   • 调用 Thread 对象的 start() 方法启动线程。

   class MyCallable implements Callable<Integer> {
       public Integer call() {
           // 线程执行的逻辑，可以返回一个结果
           return 42;
       }
   }

   public static void main(){
       // 创建并启动线程
       MyCallable myCallable = new MyCallable();
       FutureTask<Integer> futureTask = new FutureTask<>(myCallable);
       Thread thread = new Thread(futureTask);
       thread.start();
   }

   如果MyCallable 接口只用一次，可以不用创建MyCallable接口，直接通过匿名内部类或者lambda表达式简写。

   //匿名内部类 
   public static void main(String[] args) {
           //第一步  创建对象
           Callable<String> callable = new Callable<String>() {
               @Override
               public String call() throws Exception {
                   Integer sum = 0;
                   for (int i = 0; i < 100; i++) {
                       sum += i;
                   }
                   return sum.toString();
               }
           };
           //第二步 包装对象
           FutureTask<String> futureTask = new FutureTask<>(callable);
           //第三步 启动线程
           new Thread(futureTask).start();
           for (int i = 0; i < 100; i++) {
               System.out.println("--------");
           }
           try {
               String s = futureTask.get();//获取执行结果
               System.out.println("执行结果为"+s);
           } catch (InterruptedException e) {
               e.printStackTrace();
           } catch (ExecutionException e) {
               e.printStackTrace();
           }
       }

   //lambda表达式
   FutureTask<String> futureTask = new FutureTask<>(()->{
                   Integer sum = 0;
                   for (int i = 0; i < 100; i++) {
                       sum += i;
                   }
                   return sum.toString();            
   });
   new Thread(futureTask).start();

4. 使用 Executor 框架（Java 5 引入，用的少，了解即可）：

   • 创建一个实现 java.util.concurrent.Executor 接口的类或直接使用 java.util.concurrent.Executors 工厂类。

   • 将 Runnable 或 Callable 对象提交给 Executor 执行。

   Executor executor = Executors.newFixedThreadPool(10); // 创建一个固定大小的线程池
   executor.execute(new Runnable() {
       public void run() {
           // 线程执行的逻辑
       }
   });

   Runnable和Callable的差异

 Runnable 接口

1. 返回值：

   Runnable 接口没有定义任何返回值，其 run() 方法的返回类型为 void，因此不能通过 run() 方法返回执行结果。

2. 异常处理：

   run() 方法可以抛出受检查异常，但不能声明在方法签名中，必须在方法内部进行处理。

3. 用途：

   主要用于实现那些不需要返回结果的多线程任务，比如简单的并发操作或者在后台执行某些操作而不需要返回值。

Callable 接口

1. 返回值：

   Callable 接口定义了一个泛型类型 <V>，其中的 call() 方法返回一个类型为 <V> 的结果，允许线程在执行完毕后返回一个值。

2. 异常处理：

   call() 方法可以抛出受检查异常，并且在方法签名中声明可能抛出的异常，调用者需要显式处理或声明抛出。

3. 用途：

   通常用于需要在线程执行完毕后获取结果的情况，可以实现复杂的计算、数据查询等任务，并返回执行结果。

总结

• 返回值：Runnable 无返回值，Callable 有返回值。

• 异常处理：Runnable 的异常处理较为简单，Callable 可以精确控制异常的抛出和处理。

• 用途：Runnable 适合那些不需要返回结果的并发任务，Callable 则适合需要返回结果的任务，能够更方便地处理线程执行后的结果。