java进阶

1.线程与进程

1.1.线程与进程区别

  1. 线程是程序执行的最小单位，而进程是程序的一次执行过程，是操作系统分配资源的最小单位；
  2. 一个进程由一个或多个线程组成，线程是一个进程中代码的不同执行路线
  3. 进程之间相互独立，但同一进程下的各个线程之间共享程序的内存空间(包括代码段，数据集，堆等)及一些进程级的资源(如打开文件和信
    号等)，某进程内的线程在其他进程不可见；
  4. 调度和切换：线程上下文切换比进程上下文切换要快得多

1.2.多线程如何创建

1.2.1.Thread

  1. package com.sunyj.practice.t0011_进程与线程;
  3. /**
  4.  *  @author  jia  
  5.  *  @since  2020-08-15 23:35 
  6.  */
  7. public class Thread01 extends Thread {
  8.     public static void main(String[] args) {
  9.         Thread01 thread01 = new Thread01();
  10.         thread01.start();
  11.     }
  12.     @Override  
  13.     public void run() {
  14.         System.out.println("thread01运行。。。");
  15.     }
  16. }

1.2.2.Runnable

  1. package com.sunyj.practice.t0011_进程与线程;
  3. /**
  4.  *  @author  jia  
  5.  *  @since  2020-08-15 23:37 
  6.  */
  7. public class Runnable01 implements Runnable {
  8.     @Override  
  9.     public void run() {
  10.         System.out.println("runnable01运行。。。");
  11.     }
  12.     public static void main(String[] args) {
  13.         new Thread(new Runnable01()).start();
  14.     }
  15. }

1.2.3.Callable

  1. package com.sunyj.practice.t0011_进程与线程;
  3. import java.util.concurrent.Callable;
  5. /**
  6.  *  @author  jia  
  7.  *  @since  2020-08-15 23:39 
  8.  */
  9. public class Callable01 implements Callable {
  10.     @Override  
  11.     public String call() throws Exception {
  12.         System.out.println("callable01运行。。。");
  13.         return "success";
  14.     }
  15.     public static void main(String[] args) {
  16.         Callable01 callable01 = new Callable01();
  17.         try {
  18.             String call = callable01.call();
  19.             System.out.println(call);
  20.         } catch (Exception e) {
  21.             e.printStackTrace();
  22.         }
  23.     }
  24. }