1.基础概念

• 程序：是为了完成特定任务、用某种语言编写的一组指令集合，指一段静态的代码， 是一个静态概念。
• 进程：是具有一定独立功能程序的执行过程，是操作系统进行资源分配和调度的基本单位也就是说进程是可以独立运行的一段程序。
  1. 进程是程序的一次执行过程，通常是一个可执行程序在内存中的一个完整副本，每个进程都有自己的数据段，栈段，和代码段。是一个动态概念。
  2. 多进程是指操作系统能同时运行多个程序。
• 线程是进程中一个独立执行的线索，是进程中的一个实体，是CPU调度和分派的基本单位，是比进程更小的能独立运行的基本单位
  1. 线程是进程中一个实体，用来描述线程的执行，它负责执行包括在进程的地址空间中的代码，创建一个进程时候他的第一个线程称为主线程是由系统自动生产的。

2. 进程

• 每个进程都有独立的代码和数据空间（进程上下文），进程间的切换会有较大的开销，一个进程包含1~n个线程。（进程是资源分配的最小单位）
• 同一类线程共享代码空间和数据空间，每个线程拥有自己的运行栈和程序计数器，线程切换的开销较小。

2.1 进程启动的方法

//方法1：
public class Test01 {
  public static void main(String[] args) throws IOException {
      ProcessBuilder pb = new ProcessBuilder("cmd", "/c" ,"ipconfig/all");
      Process process = pb.start();
      BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream(),"GBK"));
      String s=null;
      while((s = reader.readLine())!=null){
          System.out.println(s);
      }
  }
}
//方法2：

public class Test02 {
  public static void main(String[] args) throws IOException {
      String path = "cmd"+" /c"+"ipconfig/all";
      Process process = Runtime.getRuntime().exec(path);
      BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream(),"GBK"));
      String s=null;
      while((s = reader.readLine())!=null){
          System.out.println(s);
      }
  }
}

2.2 进程的三大特征

• 独立新
• 动态性
• 并发性
  僵尸进程：是指当子线程比父线程先结束，而父进程没有回收子线程，没有回收子线程所占的资源，此时子进程称为僵尸进程，如果父进程先退出，子进程被Init接管，子进程退出侯init会释放其所占的资源----》是对系统资源的浪费，必须解决。**
  孤儿进程：是一个父进程退出，而一个或者多个子进程还在执行那么这些子进程会成为孤儿进程，孤儿进程将被init方法所收养并由init完成对其资源释放的工作，没有什么危害

2.3 并发与并行

• 并发：通过CPU调度算法，让用户看上去同时执行，实际从CPU操作层面不是真正的同时执行。
• 并行：多个CPU实列或者多台机器同时执行一段处理逻辑，是真正的同时执行

2.4 主线程

线程是进程中的一个实体，用来描述进程的执行，他负责执行包括在进程地址空间之中的代码，创建一个线程的时候，他的第一个线程称为主线程，是由系统自动创建的

• 他是产生其他子线程的线程
• 通常最后执行完毕，这里不绝对
  进程中线程之间的关系
  线程不像进程，一个进程之中的线程没有父子之分都是平级的，即当一个线程退出的时候不会影响另一个，但是所谓的主线程mian其入口代码是类似这样调用的exit(main())当main线程执行完毕之后会调用exit（）会使整个进程终止，那么所有线程自然会退出。
  进程与线程的关系
  • 一个进程可以有多个线程，至少有一个主线程，一个线程只能属于一个进程
  • 资源分配给进程，同一个进程中的所有线程共享该资源
  • 线程在执行过程中需要协作同步
  • 线程是进程内可调度的一个执行单元，也是进程内可调度的实体。

线程和进程的区别

• 调度 ：线程是CPU调度和分配的基本单元，进程是操作系统分配和调度的基本单元。
• 并发性：不仅进程之间可以并发执行，同一个进程的多个线程之间也可以并发执行，一个进程至少有一个线程（单进程单线程），一个线程必须隶属于某个进程。
• 拥有资源：进程是拥有资源的一个单位，线程不拥有资源，但是可以访问隶属与进程的资源。
• 进程和线程最大的区别在于：进程是由操作系统来控制的，而线程是由进程来控制的。
• 线程本身的数据通常只有寄存器数据，以及一个程序执行时使用的堆栈，所以线程的切换比进程切换的负担要小
• 多个进程的内部数据和状态都是完全独立的，而多线程是共享一块内存空间和一组系统资源，有可能互相影响

3. 线程创建的方式

3.1 继承Thread类

• Tread类本质上也是实现了Runable接口的一个实例，代表一个线程实例。

class Test{
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();
    }
}
class MyThread extends Thread{
    @Override
    public void run() {
        System.out.println("这是创建线程的第一种方式");
    }
}

• 启动线程的唯一方法就是调用Thread类的start()实例方法，不能直接调用run(),start()方法是一个native方法，它代表启动一个线程并执行run方法，这种方法最大的限制就是java是单根继承。

3.2 实现Runable接口

@FunctionalInterface //函数是接口 ，可以使用Lambda表达式
public interface Runnable {
    public abstract void run();
}

使用例子：

//匿名内部类形式
 new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("匿名内部类形式");
            }
        }).start();
//lambda表达式形式
 new Thread(()->{
            System.out.println("Lambda表达式形式");
        }).start();

3.3 使用Callable和Future接口创建线程

图片.png
使用好处就是可以有 返回值可以抛出异常

@FunctionalInterface//函数式接口
public interface Callable<V> {//V代表泛型
    V call() throws Exception;//可抛出异常
}

public interface Future<V>{//用于获取Callable接口中的call方法的执行结果
    boolean cancel(boolean mayIntersupteIfRunning);
    boolean isCancelled();
    boolean isDone();
    V get() throws InterruptedException, ExecutionException;
    V get(long timeout, TimeUnit unit)throws InterruptedException,   ExecutionException;
}

//继承Runable接口和Futrue接口
public interface RunnableFuture<V> extends Runnable, Future<V> {
    void run();
}

//实现RunableFutrue接口
public class FutureTask<V> implements RunnableFuture<V>

图片.png

注意:FutureTask实现了Future和Runnable接口，所以new Thread(futureTask),当执行thread.start()方法时会自动调用Callable接口实现中的call方法。当调futureTask.get()方法时可以获取对应的线程对象的执行结果，如果线程并没有返回时，当前线程阻塞等待。

3.4 使用线程池

享元模式

享元模式Flyweight Pattern主要用于减少创建对象的数量，以减少内存占用和提高性能。这种类型的设计模式属于结构型模式，它提供了减少对象数量从而改善应用所需的对象结构的方式。
优点：大大减少对象的创建，降低系统内存的使用，以提高程序执行的效率；
缺点：提高了系统的复杂度，需要分离出外部状态和内部状态，而且外部状态具有固有化的性质，不应该随着内部状态的变化而变化，否则会造成系统的混乱。

public class Test {
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(4);
        Thread[] threads = new Thread[10];
        for(int i = 0;i<10;i++){
            threads[i] = new Thread(()->{
                System.out.println("线程执行");
            });
            ;
            service.submit(threads[i]);
        }
        service.shutdown();

    }
}