javase笔记11----线程1

进程

简介

进程(Process)，是正在运行的程序实例，是操作系统进行资源分配的最小单位。

每个进程都有它自己的地址空间和系统资源（比如CPU时间，内存空间，磁盘IO等）。

多个进程可以同时执行，每个进程在运行时都不会影响其他进程的运行，资源不共享。

线程

1.线程是进程的一部分，是CPU能够进行运算调度的最小单位。

2.线程不能独立存在，必须依赖于进程。

3.线程是一个进程中的顺序执行流(执行单元)。

4.一个进程中可以有一个线程，也可能有多个线程。每个线程都有自己的指令指针、堆栈和局部变量等，但它们共享进程的代码、数据和全局变量等资源。

5.多线程可以实现并发执行，提高程序的效率。

进程和线程的区别

1. 进程是操作系统运行的一个任务，线程是进程中运行的一个任务
2. 进程是资源分配的最小单位，线程是程序执行的最小单位。
3. 进程有自己的独立地址空间，每启动一个进程，系统就会为它分配地址空间，建立数据表来维护代码段、堆栈段和数据段。
4. 线程是轻量级的进程，同一个进程中可以包含多个线程。多线程共享进程中的数据，使用相同的地址空间，因此，线程之间的通信更方便。
5. 一个进程结束，其内的所有线程都结束，但不会对另外一个进程造成影响。多线程程序，一个线程结束，有可能会造成其他线程结束

CPU核心数

现如今，一个CPU都是多核心的。

内核（处理器）：一个CPU内核在一个时间片上可以执行一个线程

逻辑处理器：同时可以处理的线程数量。(超线程时使用）

CPU时间片

概念

在宏观上，我们可以同时打开多个应用程序，每个程序同时运行，互不打扰。

但在微观上：由于只有一个CPU(一个内核而言)，一次只能运行某一个进程的某一个线程。如何公平处理，一种方法就是引入时间片的概念，每个程序轮流执行。

CPU调度机制算法，会将时间划分成一个个时间片

线程调度

线程调度是计算机多线程操作系统中分配CPU时间给各个线程的过程。每个线程代表程序中的一个执行路径，操作系统通过线程调度器分配处理器时间，决定哪个线程将获得执行的机会，以及获得的时间长短。

进程调度

进程调度是操作系统中分配CPU时间给各个进程的过程。进程是系统进行资源分配和调度的独立单位，它包含代码、数据以及分配的系统资源。与线程调度不同，进程调度涉及到的上下文切换成本更高，因为进程间共享的资源更少。

串行、并发、并行

串行是指前一个任务执行完，下一个任务才会执行；

并行是指两个或者多个事件在同一时刻发生；

并发是指两个或多个事件在同一时间间隔发生

线程的状态简介

在Java中，线程可以处于以下几种状态：

新建状态（New）：线程对象已经创建，但还没有调用start()方法。

就绪状态（Runnable）：线程已经调用start()方法，等待CPU调度执行。

运行状态（Running）：线程获得CPU时间片，开始执行run()方法里的代码。

阻塞状态（Blocked）：线程因为某些原因放弃CPU使用权，暂时停止运行，直到进入就绪状态。

等待状态（Waiting）：线程因为某些条件而进入等待状态，此时不会被分配CPU时间片，直到其他线程显式地唤醒。

超时等待状态（Timed Waiting）：线程在指定的时间内等待，时间到后会自动返回到就绪状态。

终止状态（Terminated）：线程的run()方法执行完毕或者因异常退出而结束线程的生命周期。

线程的创建

方式1：

继承Thread类，重写run方法，创建该类对象，调用start方法开启线程。start方法可以将该线程对象纳入可执行线程池中。

public static void main(String[] args){
    Thread t = new MyThread();
    t.start();
}
class MyThread extends Thread{
    public void run(){
        System.out.println("hello");
    }
}

方式2：

实现Runnable接口，重写run方法，创建Thread类对象，将Runnable子类对象传递给Thread类对象。调用start方法开启线程。

public static void main(String[] args){
    Runnable task = new MyTask();
    Thread t = new Thread(task);
    t.start();
}
class MyTask implements Runnable{
    public void run(){
        System.out.println("hello");
    }
}

方式3：

1.创建Callable接口的实现类对象，并实现call()方法。该call()方法将作为线程的执行体，该call()方法有返回值，

2.使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。

3.使用FutureTask对象作为Thread对象的target创建井启动新线程。

4.使用FutureTask对象的get()方法来获得子线程执行结束后的返回值。

public static void main(String[] args) throws ExecutionException, InterruptedException{
    Callable c = ()->{
        int sum = 0;
        for(int i = 2;i<=100;i+=2){
            sum += i;
        }
        return sum;
    };
    //调用FutureTask的构造器，传入Calllable对象
    FutureTask<Integer> futureTask = new FutureTask<>(c);
    Thread t = new Thread(futureTask);
    t.start();
    //获取线程执行结束后的结果
    int result = futureTask.get();
    System.out.println(result);

常用构造器

第一种：

Thread(Runnable runnable)

使用指定Runnable对象作为参数，创建一个Thread对象

public  static void main(String[] args){
    Runnable test = ()->{
        int[] arr = new int[5];
        for(int i = 0;i<arr.length-1;i++){
            arr[i] = (int)(Math.random()*101);
        }
        for(int i = 0; i< arr.length;i++){
            for(int j = 0;j<arr.length-1;j++){
                if(arr[j]>arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    };
    Thread t = new Thread(test);
    t.start();
} 

第二种：

Thread(Runnable runnable, String name)

使用指定Runnable对象作为参数，创建一个Thread对象，并指定对象名为name

public static void main(String[] args){
    Runnable r = new Runnable(){
        public void run(){
            //获取所在线程的名字
            String name = Thread.currentThread().getName();
            for(int i = 0;i<10;i++）{
                System.out.println(name+"helloworld");
            }
        }
    };
    Thread t = new Thread(r,"thread-A");
    t.start();

第三种：

Thread(String name)

创建一个Thread对象，并指定名称为name

public static void main(String[] args){
    Thread t = new Thread("thread-B"){
        public void run(){
            String name = this.getName();
            for(int i = 0; i<10; i++){
                System.out.println(name+"12345");
            }
        }
    };
    t.start();
}