线程知识巩固第一节

1. 什么是线程？
   线程：操作系统能够进行运算调度的最小单位。
   它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。
2. 线程的开启方式有几种？怎么实现？
   开启线程的方式有三种：

   1. 继承Thread类（重写run方法）

               public class Main {
           
               public static void main(String[] args) {
           
                   System.out.println("Hello World!");
                   new MyThread("张三的线程 ").start();
               }
           
           
               // 第一种
               public static class MyThread extends Thread {
           
                   public MyThread(String name) {
                       super(name);
                   }
           
                   @Override
                   public void run() {
                       for (int i = 0; i < 25; i++) {
                           System.out.println(Thread.currentThread().getName() + "：正在工作 " + i);
                       }
                   }
               }
           }
      

      

   2. 实现Runnable接口（重写run方法）
      实现Runnable接口的好处：
      1.Runnable接口避免了单继承的局限性。
      2.Runnable接口对线程对象和线程任务进行解耦
      线程组成部分分为两种：线程对象和线程任务。
      继承Thread类，线程对象和线程任务耦合，一旦创建Thread类的子类对象，既是线程对象，又有线程任务。
      实现Runnable接口，将线程任务单独封装成对象，类型就是Runnable接口类型。

        public static void main(String[] args) {
       
           System.out.println("Hello World!");
           MyRunnable myRunnable = new MyRunnable();
           Thread thread = new Thread(myRunnable);
           thread.start(); }
       
       
       // 第二种 
       public static class MyRunnable implements Runnable {
       
           @Override
           public void run() {
               for (int i = 0; i < 25; i++) {
                   System.out.println(Thread.currentThread().getName() + "：正在工作 " + i);
               }
           } 
        }
      

      

   3. 线程池（实现callable接口，重写call()方法）
      线程池的优势：
      1.多线程的情况下尽量使用线程池。
      2.线程的创建和销毁是开销比较大的。

         public static void main(String[] args) {
      
               System.out.println("Hello World!");
               //开启线程池,初始化线程池的个数
               ExecutorService executorService = Executors.newFixedThreadPool(5);
               //  创建接口实现类
               MyCallAble mCallAble = new MyCallAble();
               //从线程池中获取线程对象,然后调用MyRunnable中的run()
               //注意：submit方法调用结束后，程序并不终止，是因为线程池控制了线程的关闭。将使用完的线程又归还到了线程池中
               //Future接口：用来记录线程任务执行完毕后产生的结果。
               Future<String> f = executorService.submit(mCallAble);
               try {
                   //获得线程池里面的内容
                   System.out.println(f.get());
               } catch (InterruptedException e) {
       
                   e.printStackTrace();
               } catch (ExecutionException e) {
       
                   e.printStackTrace();
               }
       
           }
       
       
           // 第三种
           public static class MyCallAble implements Callable<String> {
       
               @Override
               public String call() throws Exception {
                   return "我是线程池";
               }
           }