多线程

• 进程
  • 在操作系统中运行的程序就是进程，进程就是执行程序的一次执行过程，它是一个动态的概念式系统资源分配的单位
  • 通常再一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义，线程是CPU调度和执行的单位
• 线程
  • 线程就是独立的执行路径
  • 在程序运行时,即使没有自己创建线程，后台也会有多个线程，比如主线程，GC线程
  • main()称之为主线程,为系统的入口，用于执行整个程序
  • 在一个进程中,如果开辟了多个线程,线程的运行是由调度器安排调度的，调度器是与操作系统紧密相关的，先后顺序是不能人为干预的
  • 对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制
  • 线程会带来额外的开销，如CPU调度时间，并发控制开销
  • 每个线程在自己的工作内存交互，内存控制不当会造成数据不一致
• 多线程
  • 多条执行路径，主线程与子线程并行交替执行（普通方法只有主线程一条路径）

线程的创建（重要）

• ·Thread class 继承Thread类（重点）

  • 自定义线程类，继承Thread类

  • 重写run()方法，编写线程执行体

  • 在主函数中创建一个线程对象，调用start()方法开启线程。

  • package com.fjbc.多线程;
    // 创建线程方式一:继承Thread类，重写run（）方法，调用start开启线程
    // 总结:注意，线程开启不一定立即执行，由CPU调度执行
    
    public class TestThread extends Thread {
        @Override
        public void run() {
            //run方法线程方法体
            for (int i = 0; i < 20; i++) {
                System.out.println("我在看代码----" + i);
            }
        }
    
        public static void main(String[] args) {
    
            //创建一个线程对象
            TestThread testThread = new TestThread();
    
            //start开启线程
            testThread.start();
            
            //主线程
            for (int i = 0; i < 200; i++) {
                System.out.println("我在学习多线程-----" + i);
            }
        }
    }
    

• Runnable接口 实现Runnable接口（重点）

  package com.fjbc.多线程;
  
  public class TestThread2 implements Runnable {
      @Override
      public void run() {
          //run方法线程方法体
          for (int i = 0; i < 20; i++) {
              System.out.println("我在看代码----" + i);
          }
      }
  
      public static void main(String[] args) {
  
          //创建一个线程对象
          TestThread2 testThread2 = new TestThread2();
  
          //创建线程对象，通过线程对象来开启线程，代理
  //        Thread thread = new Thread(testThread2);
  //
  //        //start开启线程
  //        thread.start();
          new Thread(testThread2).start();
  
          //主线程
          for (int i = 0; i < 200; i++) {
              System.out.println("我在学习多线程-----" + i);
          }
      }
  }
  
  

• Callable接口 实现Callable接口（了解）

  package com.fjbc.多线程;
  
  
  import java.util.concurrent.*;
  
  public class TestCallable2 implements Callable<Boolean> {
      @Override
      public Boolean call() throws Exception {
          System.out.println("创建成功");
          return true;
      }
  
      public static void main(String[] args) {
          TestCallable2 callable = new TestCallable2();
  
          //创建执行服务
          ExecutorService service = Executors.newFixedThreadPool(1);
          //提交执行
          Future<Boolean> result = service.submit(callable);
  
          try {
              boolean isTrue = result.get();
          } catch (InterruptedException e) {
              e.printStackTrace();
          } catch (ExecutionException e) {
              e.printStackTrace();
          }
          service.shutdownNow();
      }
  }