浅剖Java进程与线程

前进前进…

操作系统（OS）

一.概念

  计算机系统包含基本程序的集合，称为操作系统（OS），我们可以笼统地理解为操作系统包含内核（进程管理、内存管理、文件管理以及驱动管理等）和其他程序（如函数库和shell程序）

二.定位

  整个有关计算机软硬件的架构中，操作系统的定位是搞管理的软件，具体怎么理解呢，通过下图可以对OS有个清晰的认知：

1.按照管理者的任务可以分为两类：硬件管理和软件管理
2.按照目标对象分为两种：对内管理和对外业务管理

---

进程

一.进程是什么？

  对于操作系统而言，一个任务就是一个进程（Process）；基于课本中的概念，可以将进程看作一个执行的实例或者一个正在执行的程序；基于内核观点，进程是担当分配资源（CPU时间、内存）的的实体，是操作系统分配资源的最小单位。

二.时间片怎么理解？

  现在的操作系统都是支持多任务的，也就是说系统支持同时运行多个任务。操作系统对任务的调度采用“时间片轮转”的调度方式，当一个任务执行一小段时间后强制暂停然后去执行下一个任务，每个任务轮流执行。
  任务执行的一小段时间称为时间片；任务正在执行的状态为运行状态；任务执行一段时间后强制暂停后去执行下一个任务，被暂停的任务处于就绪状态等待下一个属于它的时间片的到来。

三.并发与并行的理解

  由于任务数量远远超过CPU核心数量，因此操作系统会自动把任务调度到每个核心上执行。

并发：多个进程在一个CPU下采用时间片轮转方式，在一段时间内，让多个进程得以推进，类似“雨露均沾”思想，一个CPU在短时间内会自动调度不同任务。
并行：多个任务在多个CPU分别同时运行，这称之为并行。

操作系统中将并发性与并行性做明显区分，主要从微观角度而言：

并发性：单处理机情况下，多个进程在同一时间间隔运行
并行性：多处理机情况下，多个进程同时运行

举个例子理解并发与并行机制：

客户去银行办理业务

并发性：为了让银行服务人员更好地服务客户，规定每个客户的业务办理时间（防止其他客户长时间等待），银行服务人员将时间片轮转思想应用到客户业务中，当该客户业务的办理时间到达规定时间，银行人员暂停当前业务随之去办理下一个客户的业务，该客户等待下一次时间片的到来。从长时间来看，因为时间片较短，一个银行服务人员被认为可同时服务多个客户，这就可以理解为基于时间片的进程轮转管理机制，就是所谓的并发性。
并行性：银行如果非常有钱，雇佣了很多的工作人员，此时一个客户就会有一个工作人员对接，所有客户的业务真正实现了同时处理，这种机制就称为并行性。

四.内核态与用户态指的什么？

  操作系统对执行权限进行分级：内核态和用户态，其中内核态指的是操作系统内核直接控制硬件设备底层软件，权限最高；用户态指的是用户程序权限最低。

五.进程上下文

  进程上下文简单来说就是进程在时间片轮转时，需要进行上下文环境切换。这是什么意思呢？

当一个线程正在执行的时候，CPU中保存了寄存器的值、进程的状态以及堆栈上的内容，基于时间片轮转机制切换该进程时，需要保存该进程当前的内容，也就是记录进程的上下文，当再一次执行该进程时，能够恢复到切换时的状态，从而继续正常地执行。

六.进程的状态有哪些？

如下图所示，进程地状态有5个，分别是创建、就绪、运行、阻塞、终止。

---

线程

一.线程的认识

1.概念

线程是系统调度资源的最小单位，可认为是“轻量级进程”。

2.线程优点

线程创建时占用更少的资源，进程中的不同线程之间可以共享资源。其中线程可以共享的资源有：①打开的文件 ②共享的内存（如对象 new Object()）。

3.线程与进程的区别是什么？

①进程是操作系统分配资源的最小单位；线程是操作系统调度资源的最小单位。
②进程之间不可以共享资源，而线程之间可以共享资源。
③一个进程中至少包含一个线程（主线程），线程必须依附于进程当中。
④线程是进程执行的最小单位，也是进程执行的实际单位。
⑤进程与线程的区别就像工厂与生产流水线一样，工厂运作的本质是流水线的运行。

二.线程的3类创建方式

1.继承Thread类创建（2种）

第一种：
public class ThreadDemo4 {
   

    static class MyThread extends Thread {
   
        @Override
        public void run() {
   
            // 线程业务
            System.out.println("线程名称：" +
                    Thread.currentThread().getName());
        }
    }

    public static void main(String[] args) {
   
        // 创建线程对象
        Thread t1 = new MyThread();
        // 启动线程
        t1.start();
        System.out.println("当前线程的名称（主线程）：" +
                Thread.currentThread().getName());

    }
}
===========================================================
第二种：
public class ThreadDemo5 {
   
    public static void main(String[] args) {
   

        Thread thread = new Thread() {
   
            @Override
            public void run() {
   
                System.out.println("线程名：" +
                        Thread.currentThread().getName());
            }
        };
        thread.start();
    }
}

2.实现Runable接口（3种）

第一种：
public class ThreadDemo6 {
   
    static class MyRunnable implements Runnable {
   
        @Override
        public void run() {
   
            System.out.println("线程名：" +
                    Thread.currentThread().getName());
        }
    }

    public static void main(String[] args) {
   
        // 1.创建Runnable对象
        MyRunnable runnable = new MyRunnable();
        // 2.创建Thread对象
        Thread thread = new Thread(runnable);
        // 3.启动线程
        thread.start();
    }
}
==========================================================
第二种：
public class ThreadDemo7 {
   
    public static void main(String[] args) {
   
        // 匿名内部类的方式实现线程
        Thread thread = new Thread(new Runnable() {
   
            @Override
            public void run() {
   
                System.out.println("线程名：" +
                        Thread.currentThread().getName());
            }
        });
        thread.start();
    }
}
==========================================================
第三种：jdk1.8开始使用
public class ThreadDemo8 {
   
    public static void main(String[] args) {
   
        // lambda + 匿名runnable的实现方式
        Thread thread = new Thread(() -> {
   
            System.out.println("线程名：" +
                    Thread.currentThread().getName());
        });
        thread.start();
    }
}

3.实现Callable接口（1种）

import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * 前面两类创建线程的方程线，线程业务都没有返回方法，
 * 为了得到线程的执行结果，实现 Callable 接口 + Future 的方式
 */
public class ThreadDemo9 {
   

    // 创建了线程的任务和返回方法
    static class MyCallable implements Callable<Integer> {
   
        @Override
        public Integer call() throws Exception {
   
            // 生成随机数
            int num = new Random().nextInt(10);
            System.out.println("子线程：" +
                    Thread.currentThread().getName() +
                    ",随机数：" + num);
            return num;
        }
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
   
        // 1.创建Callable对象
        MyCallable myCallable = new MyCallable();
        // 2.创建FutrueTask对象接收返回值
        FutureTask<Integer> futureTask =
                new FutureTask<>(myCallable);
        // 3.创建Thread对象
        Thread thread = new Thread(futureTask);
        // 启动线程
        thread.start();
        // 拿到线程执行的结果
        int result = futureTask.get();
        System.out.println(String.format("线程名：%s,数字：%d",
                Thread.currentThread().getName(), result));
    }
}

三.线程的休眠方式

例如：实现主线程休眠1s

1.方式1

Thread.sleep()

public static void main(String[] args) throws InterruptedException {
   
    System.out.println("开始时间：" + new Date());
    // 休眠1s
    Thread.sleep(1000);  //sleep方法传入的时间以毫秒计算
    System.out.println("结束时间：" + new Date());
}

2.方式2

TimeUnit.SECONDS.sleep(1)

public static void main(String[] args) throws InterruptedException {
   
    System.out.println("开始时间：" + new Date());
    TimeUnit.SECONDS.sleep(1); // 休眠1s
    System.out.println("结束时间：" + new Date());
}

3.方式3

Thread.sleep(TimeUnit.SECONDS.toMillis())

public static void main(String[] args) throws InterruptedException {
   
    System.out.println("开始时间：" + new Date());
    Thread.sleep(TimeUnit.SECONDS.toMillis(1)); //休眠1s
    System.out.println("结束时间：" + new Date());
}

4.例题：使用两个线程打印“AABBCCDD”

public static void main(String[] args) {
   
        // 创建一个任务
        Runnable runnable = new Runnable() {
   
            @Override
            public void run() {
   
                String data = "ABCD";
                for (char item : data.toCharArray()) {
   
                    System.out.print(item);
                    try {
   
                        // 休眠一段时间
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
   
                        e.printStackTrace();
                    }
                }
            }
        };

        Thread t1 = new Thread(runnable);
        Thread t2 = new Thread(runnable);
        t1.start();
        t2.start();
    }

程序运行结果：

四.线程其他

Thread类是Jvm用来管理线程的类，每个线程都有一个唯一的Thread对象与之关联。Thread类的对象就是用来描述一个线程执行流的，Jvm会将这些对象组织起来用于线程调度和线程管理。

1.Thread类常用构造方法

2.Thread类常用属性

线程优先级补充：

3.线程分类

线程分为守护线程（又叫后台线程）和用户线程（默认线程）

（1）守护线程与用户线程的区别

• Java语言中，默认创建的是用户线程。
• 守护线程是用来为用户线程服务的，当一个程序中的所有用户线程结束之后，无论守护线程是否在工作，守护线程都会随用户线程一起结束。举个例子来说，守护线程的角色就像“服务员”，而用户线程的角色就像“顾客”，当顾客全部走了之后（执行结束），“服务员”就没有了存在的意义，因而整个程序就直接结束运行。
• 守护线程从业务逻辑层面来看权重比较低，但对于线程调度器来说无论是守护线程还是用户线程，在优先级相同的情况下被执行的概率都是相同的。

（2）如何将线程设置为守护线程？

主线程和默认创建的线程都是用户线程，如下代码所示：

public static void main(String[] args) {
   
    Thread thread = new Thread(new Runnable() {
   
        @Override
        public void run() {
   
            System.out.println("我是子线程");
        }
    });
    System.out.println("子线程是否为守护线程：" + thread.isDaemon());
        
    //Thread.currentThread()获取当前执行代码的线程对象
    System.out.println("主线程是否为守护线程：" + Thread.currentThread().isDaemon());
}

程序的执行结果：

从结果可以看出主线程和创建的子线程默认都是用户线程，那么我们想让用户线程变为守护线程如何去做呢？

通过setDaemon(true)将用户线程设置为守护线程，如下面代码所示：

public static void main(String[] args) {
   
     Thread thread = new Thread(new Runnable() {
   
         @Override
         public void run() {
   
             System.out.println("我是子线程");
         }
     });
     // 设置子线程为守护线程
     thread.setDaemon(true);
     System.out.println("子线程是否为守护线程：" + thread.isDaemon());
     System.out.println("主线程是否为守护线程：" + Thread.currentThread().isDaemon());   
}

程序的执行结果：

从结果可以看出，子线程由默认false变为true，表明子线程被设置为守护线程。

（3）守护线程的注意事项

1）设置守护线程setDaemon(true)必须放在启动线程之前start()，否则程序将报错。
2）在守护线程中创建的线程都是守护线程。
3）使用join()方法时会等待线程执行完，无论是用户线程还是守护线程。

通过代码看一下注意事项：
1）将setDaemon(true)放在start()之后

public static void main(String[] args) throws InterruptedException {
   
    Thread thread = new Thread(new Runnable() {
   
        @Override
        public void run() {
   
            for (int i = 1; i <= 10; i++) {
   
                // 打印i信息
                System.out.println("i:" + i + ",isDaemon:" +
                            Thread.currentThread().isDaemon());
                try {
   
                    // 休眠100毫秒
                    Thread.sleep(100);
                } catch (InterruptedException e) {
   
                    e.printStackTrace();
                }
             }
         }
     });
     // 启动线程
     thread.start();
     // 设置为守护线程
     thread.setDaemon(true);
}

程序运行结果：

从结果可以看出，将setDaemon(true)放在start()之后，程序运行报错，此外设置的守护线程也不能生效。

2）守护线程的子线程

public static void main(String[] args) throws InterruptedException {
   
    Thread thread = new Thread(new Runnable() {
   
        @Override
        public void run() {
   
            Thread thread2 = new Thread(new Runnable() {
   
                @Override
                public void run() {
   

                }
            });
            System.out.println("守护线程的子线程是否为守护线程：" +
                        thread2.isDaemon());
       }
   });
   // 设置为守护线程
   thread.setDaemon(true);
   // 启动线程
   thread.start();
   Thread.sleep(1000);
}

程序运行结果：

从结果可以看出，守护线程中创建的子线程默认也是守护线程。

3）使用join()方法等待守护线程执行结束

默认情况下，程序运行结束不会等待守护线程执行完，当调用线程的等待方法join()时，程序会等待守护线程执行结束后再结束进程。

public static void main(String[] args) throws InterruptedException {
   
        Thread thread = new Thread(new Runnable() {
   
            @Override
            public void run() {
   
                for (int i = 1; i <= 10; i++) {
   
                    // 打印 i 信息
                    System.out.println("i:" + i);
                    try {
   
                        // 休眠 100 毫秒
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
   
                        e.printStackTrace();
                    }
                }
            }
        });
        // 设置为守护线程
        thread.setDaemon(true);
        // 启动线程
        thread.start();
        // 等待线程执行完
        thread.join();
        System.out.println("子线程是否为守护线程：" + thread.isDaemon());
        System.out.println("主线程是否为守护线程：" + Thread.currentThread().isDaemon());
    }

程序运行结果：

从结果我们可以看出，守护线程调用等待方法join()，程序会等待守护线程将任务执行结束后结束进程。

（4）守护线程的使用场景

守护线程的经典使用场景是垃圾回收线程；守护线程中创建的线程默认情况下也是守护线程。

五.面试题：start()和run()的区别

Java中通过实例化Thread类产生线程对象，线程对象调用start()启动线程，Thread还有一个run方法貌似也能启动线程，两者的区别到底是什么？

start()：产生线程对象后，调用start()方法启动线程，线程处于运行状态RUNNABLE中的Ready就绪状态中，此时线程等待被CPU调度，调度后再执行run()方法，使用start()方法启动线程，真正实现了多线程。
run()：run()方法是Thread中一个普通方法，直接用线程对象调用run()方法，会运行在主线程中。因为程序中只有一个主线程，当程序中有两个线程时，直接调用run()方法，程序按照顺序执行，没有实现多线程。

public static void main(String[] args) {
   
    Thread t1 = new Thread(new Runnable() {
   
        @Override
        public void run() {
   
            System.out.println(Thread.currentThread().getName());
        }
    },"unstoppbale_t");
    t1.start();
}

程序运行结果：

可以看出，调用start()方法启动线程，线程名是子线程名。

public static void main(String[] args) {
   
    Thread t1 = new Thread(new Runnable() {
   
        @Override
        public void run() {
   
            System.out.println(Thread.currentThread().getName());
        }
    },"unstoppbale_t");
    t1.run();
}

程序运行结果：

可以看出，调用start()方法启动线程，线程名是主线程名main。

细节补充：
run()方法可调用多次，而start()方法只能调用一次，调用多次将会报错，如下图两图所示：

六.线程的终止方式

1.使用自定义的全局变量终止线程
特点：终止方法比较温柔，在拿到终止指令后，需要执行完当前的任务才会终止线程

public class ThreadDemo {
   

    // 全局自定义变量
    private static boolean flag = false;

    public static void main(String[] args) throws InterruptedException {
   
        // 转账线程
        Thread t1 = new Thread(new Runnable() {
   
            @Override
            public void run() {
   
                while (!flag) {
   
                    try {
   
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
   
                        e.printStackTrace();
                    }
                    System.out.println("正在讲话...");
                }
                System.out.println("停止说话");
            }
        });
        t1.start();

        Thread t2 = new Thread(new Runnable() {
   
            @Override
            public void run() {
   
                try {
   
                    Thread.sleep(310);
                } catch (InterruptedException e) {
   
                    e.printStackTrace();
                }
                // 改变变量的值来终止线程
                System.out.println("停止说话，有要事发生。");
                flag = true;
            }
        });
        t2.start();
        t1.join(); //对于用户线程而言，join()可以不写
        t2.join();
    }

}

程序运行结果：

从运行结果我们可以看出，使用全局变量方式“终止说话”后又有一次“正在说话”，这说明全局变量控制线程终止会让当前任务结束后再进行终止。

2.调用线程终止方法interrupt()终止
特点：在收到终止指令后，立马结束进程的执行

①Thread.interrupted()

public class ThreadDemo {
   
    public static void main(String[] args) throws InterruptedException {
   
        // 转账线程
        Thread t1 = new Thread(new Runnable() {
   
            @Override
            public void run() {
   
                while (!Thread.interrupted()) {
   
                    try {
   
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
   
                        e.printStackTrace();
                        System.out.println("终止状态" +
                                Thread.currentThread().isInterrupted());
                        break;
                    }
                    System.out.println("正在说话...");
                }
                System.out.println("停止了说话");
            }
        });
        t1.start();

        Thread.sleep(310);
        // 终止线程
        System.out.println("停止说话，有要事发生");
        t1.interrupt();
    }
}

程序运行结果：

②Thread.currentThread().isInterrupted()

public class ThreadDemo {
   
    public static void main(String[] args) throws InterruptedException {
   

        Thread t1 = new Thread(new Runnable() {
   
            @Override
            public void run() {
   
                while (!Thread.currentThread().isInterrupted()) {
   
                    System.out.println("正在说话");
                }
                System.out.println("停止了说话");
            }
        });
        t1.start();

        Thread.sleep(3);
        System.out.println("停止说话，有要事发生");
        t1.interrupt();
    }
}

从上面两个图运行结果可以看出，调用interrupt()直接终止正在执行的线程，不管线程是否在执行任务。

那么Thread.interrupted()和Thread.currentThread().isInterrupted()区别是什么呢？通过以下代码运行结果来观察：

①Thread.interrupted()

public class ThreadDemo {
   
    public static void main(String[] args) {
   

        Thread t1 = new Thread(new Runnable() {
   
            @Override
            public void run() {
   
                for (int i = 0; i < 10; i++) {
   
                    System.out.println(Thread.interrupted());
//                    System.out.println(Thread.currentThread().isInterrupted());
                }
            }
        });
        t1.start();
        // 终止线程
        t1.interrupt();
    }
}

②Thread.currentThread().isInterrupted()

public class ThreadDemo6 {
   
    public static void main(String[] args) {
   

        Thread t1 = new Thread(new Runnable() {
   
            @Override
            public void run() {
   
                for (int i = 0; i < 10; i++) {
   
                    //System.out.println(Thread.interrupted());
                    System.out.println(Thread.currentThread().isInterrupted());
                }
            }
        });
        t1.start();
        // 终止线程
        t1.interrupt();
    }
}

Thread.interrupted()是全局的方法，执行线程终止状态变为true，之后就会复位为初始默认状态false。Thread.currentThread().isInterrupted()将线程中的终止状态由false变为true，不再复位。

3.使用线程提供的方法stop()终止【已弃用】

七.线程的状态

线程的状态分为六种：

八.*多线程风险：线程安全

1.什么称作线程不安全？

多线程环境中，程序的执行结果与预期结果不相符，这就叫线程不安全。

线程不安全举例：

public class ThreadDemo7 {
   

    static class Counter {
   
        // 定义的私有变量
        private int num = 0;
        // 执行次数
        private final int maxSize = 100000;

        // num++
        public void incrment() {
   
            for (int i = 0; i < maxSize; i++) {
   
                num++;
            }
        }

        // num--
        public void decrment() {
   
            for (int i = 0; i < maxSize; i++) {
   
                num--;
            }
        }

        public int getNum() {
   
            return num;
        }
    }

    public static void main(String[] args) throws InterruptedException {
   
        Counter counter = new Counter();

        Thread t1 = new Thread(() -> {
   
            counter.incrment();
        });
        t1.start();

        Thread t2 = new Thread(() -> {
   
            counter.decrment();
        });
        t2.start();

        t1.join();
        t2.join();

        System.out.println("最终的执行结果：" + counter.getNum());
    }
}

对于上述代码，我们预期得到的结果为0，然而执行后的结果不为0，这就是线程不安全的例子。

举例分析原因：
使用两个线程对变量count进行一次++和- -。

原因：Jvm中，线程占有两块内存，其中一个是主内存，另外还有线程自己的工作内存，++和- -操作实际上分为三步完成。

2.线程不安全原因有哪些？

（1）CPU抢占执行
（2）非原子性
（3）编译器优化（指令重排） 编译器优化在单线程下执行没问题，多线程下优化会发生混乱
（4）内存的不可见性
（5）多个线程修改了同一个变量

后续更新中。。。

转载：https://blog.csdn.net/weixin_44874269/article/details/116405054