1. 继承Thread类

   public class ExtendsThreadDemo extends Thread{
       @Override
       public void run() {
           System.out.println("通过继承的方式实现多线程！！！");
       }
   }
   
   public class Demo {
       public static void main(String[] args) throws InterruptedException {
           //继承Thread
           ExtendsThreadDemo extendsThreadDemo = new ExtendsThreadDemo();
           extendsThreadDemo.start();
       }
   }
   

2. 实现Runnable接口（针对已经存在继承）

   public class ImplementsRunableDemo implements Runnable{
       @Override
       public void run() {
           System.out.println("继承Runnable实现多线程");
       }
   }
   
   public class Demo {
       public static void main(String[] args) throws InterruptedException {
           //实现Runnable接口
           ImplementsRunableDemo demo = new ImplementsRunableDemo();
           Thread thread = new Thread(demo);
           thread.start();
       }
   }
   

3. 实现Callable接口（针对需要返回值）

   public class ImplementsCallableDemo implements Callable {
       @Override
       public Object call() throws Exception {
           System.out.println("实现callable接口");
           return "call success";
       }
   }
   
   public class Demo {
       public static void main(String[] args) throws InterruptedException {
   //基于Callable
           ExecutorService pool = Executors.newFixedThreadPool(10);
           List<Future> list = new ArrayList<>();
           for (int i = 0; i < 10; i++) {
               ImplementsCallableDemo callableDemo = new ImplementsCallableDemo(i + " ");
               Future submit = pool.submit(callableDemo);
               Thread.sleep(1000);
               list.add(submit);
           }
           list.forEach(future -> {
               try {
                   System.out.println(future.get().toString());
               } catch (InterruptedException e) {
                   e.printStackTrace();
               } catch (ExecutionException e) {
                   e.printStackTrace();
               }
           });
           pool.shutdown();
       }
   }
   

4. 基于线程池

   //4.基于线程池
   ExecutorService executorService = Executors.newFixedThreadPool(10);
   while (true) {
       executorService.submit(() -> {
           System.out.println(Thread.currentThread().getId() + " is running..");
           try {
               Thread.sleep(1000);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       });
   }
   

四种线程池

• newCachedThreadPool
  创建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们。对于执行好多短周期异步任务的程序而言，这些线程池通常可以提高程序性能。调用execute将重用以前构造的线程（如果线程可用）。如果现有线程无可用的，则创建一个新线程添加到池中。终止并从缓存中移除那些已有60s未被使用的线程。因此，长时间保持空闲的线程不会使用任何资源。
• newFixedThreadPool
  创建一个可用固定线程数的线程池，以共享的无界队列的方式运行这些线程。在任意点，在大多数nThreads线程会处理任务的活动状态。如果在所有线程处于活动状态时提交附加任务，则在可用线程之前，附加任务将在队列中等待。如果在关闭前的执行期间由于失败而导致任何线程终止，那么一个新线程将替代它执行后续的任务。在某个线程被显示得关闭之前，池中的线程将一直存在。
• newScheduledThreadPool
  创建一个线程池，它可安排在给定延迟后运行命令或者定期执行。

  ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3);
  scheduledExecutorService.schedule(() -> System.out.println("延迟三秒执行..."), 3, TimeUnit.SECONDS);
  scheduledExecutorService.scheduleAtFixedRate(() -> System.out.println("延迟一秒后每三秒执行一次"), 1, 3, TimeUnit.SECONDS);
  

• newSigleThreadExecutor
  仅有一个线程的线程池，这个线程池可以在线程死后（或者异常时）重新启动一个线程来替代原来的线程继续执行。

关于线程的run()和start()区别：

• 调用start()是用于启动线程的，轮到线程执行，便会执行run()；若直接调用run()虽然也能够执行到run()中的内容，但是却失去了多线程的意义了相当于主线程线性得执行了Thread的run()。
• 一个线程仅可执行一次start()，而run()方法无限制