【多线程系列】线程的创建

进程和线程的区别，能否举例说明？

① 进程是包含线程的，每个进程至少有一个线程，称为主线程
② 进程是系统资源分配的最小单位，线程是系统资源调度的最小单位
③ 进程和进程之间不共享内存空间，同一进程的多个线程共享同一内存空间(虚拟地址空间+文件描述符表)

我们可以通过进程控制块PCB中的PID号判断是否属于同一进程。如果PID相同就表示是同一个进程（共享一份内存资源）。
那么，Java的线程和操作系统的线程之间的关系是什么样的？
线程是操作系统中的概念，操作系统根据线程的有关特性提供了一组API供用户使用。Java标准库中的Thread类对操作系统提供的API进行了抽象和封装。我们使用多线程可以增加程序整体的运行速度，但是线程的创建、销毁和调度都是有开销的，所以也不是成倍提升效率。

有关进程和线程我们也可以 举个栗子❤ 来说明：
我们可以把进程当作是一个工厂，工厂至少有一条生产线（线程），这些生产线共享这家工厂的所有资源。但是，这也有可能会发生线程不安全的现象。比如，这家工厂只剩下一份原材料仅供一条生产线使用了，这些生产线可能会出现资源掠夺的现象。再者，如果有3条生产线分别负责造三种不同组件，组装零件三种组件缺一不可，此时任意一条生产线出问题，都会发生进程异常的现象。

线程的创建方式有几种？

大致分为5种，以下方式都是借助Thread类，在操作系统的内核中创建PCB，加入内核的双向链表中。
1.继承Thread类 （重写run()方法）
2.实现Runnable接口
3.匿名内部类创建Thread子类对象
4.匿名内部类创建Runnable子类对象
5.Lambda表达式创建Runnable子类对象

class MyThread3 extends Thread{
    @Override
    public void run() {
        System.out.println("hello, Thread1");
    }
}
class MyRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println("hello, Thread2");
    }
}

public class testDemo3 {
    //MyThread继承Thread类
    public static void main1(String[] args) {
        Thread t = new MyThread3();
        t.start();
    }

    //Runnable接口
    public static void main2(String[] args) {
        Thread t = new Thread(new MyRunnable());  //实例作为Thread构造方法中的参数
        t.start();
    }

    //匿名内部类(Thread类)
    public static void main3(String[] args) {
        Thread t = new Thread(){
            @Override
            public void run() {
                System.out.println("hello, Thread3");
            }
        };
        t.start();
    }

    //匿名内部类(Runnable接口)
    public static void main4(String[] args) {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello, Thread4");
            }
        });
        t.start();
    }

    //lambda表达式创建Runnable子类对象
    public static void main5(String[] args) {
        Thread t = new Thread(()->{
            System.out.println("hello, Thread5");
        });
        t.start();
    }

}

Java中 Thread类及其常见方法你了解哪些？

1.构造方法

① Thread() 创建线程对象
② Thread(Runnable target) 使用Runnable对象创建线程对象
③ Thread(String name) 创建线程对象，并命名
④ Thread(Runnable target, String name) 使用Runnable对象创建线程对象并命名

2.常见属性

属性	获取方法
ID	getId()
名称	getName()
状态	getState() //辅助进行线程调度
优先级	getPriority()
是否后台进程	isDaemon() //影响JVM进程是否能够退出，JVM会在一个进程的所有非后台线程结束后，才会结束运行
是否存活	isAlive() //针对PCB，判断当前内核中的PCB是否存在
是否被中断	isInterrupted()

3.run()和start()的区别

我们通过继承Thread类创建一个线程时，要重写run()方法，将线程要做的事情写在run()方法的内部，最后要调用start()方法启动线程。
run()方法可以被看作是一张清单列表，里面记录了线程要干的事情；
start()方法表示执行命令，一旦调用，线程才真正独立执行；
启动线程我们用start()方法，即在操作系统内核中创建PCB，run()方法一旦执行完毕，就表明线程结束，同时内核中的PCB也释放销毁。

4.join()和sleep()的区别

join()：等待一个线程；控制线程结束的先后顺序，调用这个代码的线程就会阻塞等待(BLOCKED状态)，好比我们使用Scanner键盘接收数据时线程就会阻塞等待。join()内部实现是wait()方法，因此它会释放锁，其他线程可以调用该线程的同步方法。
sleep()：休眠当前线程，本质上是将该线程的PCB从就绪队列转移至阻塞队列；此外还可以设置一定的休眠时间(参数)；sleep()不释放锁，线程会一致等待下去，直到任务完成才会释放锁。

5.获取到当前线程的引用

public static Thread currentThread(); //返回当前线程对象的引用

//运用的前提是 继承Thread类，重写run()方法
//如果使用Runnable接口创建子类对象，则this表示的是Runnable实例，而不是Thread实例，同时也就没有getName()方法了
public class ThreadDemo{
	public static void main(String[] args){
		Thread thread = Thread.currentThread();
		System.out.println(thread.getName());
	}
}

6.线程的中断机制

① 中断一个线程
中断线程的结果是死亡、还是等待新的任务或是继续运行至下一步，都取决于这个程序本身。线程的thread.interrupt()方法是中断线程，将会设置该线程的中断状态位，即设置为true；程序在运行过程中，时不时会检查这个中断标志位是否为True，判断该线程是否中断。
② 判断线程是否被中断
判断某个线程是否已被发送过中断请求，请使用Thread.currentThread().isInterrupted()方法（因为它将线程中断标示位设置为true后，不会立刻清除中断标示位，即不会将中断标设置为false），而不要使用thread.interrupted()（该方法调用后会将中断标示位清除，即重新设置为false）方法来判断。
③ 如何中断线程
如果线程因为调用了wait/join/sleep等方法而阻塞挂起，则以InterruptedException异常的形式通知，清除中断标志(将中断标志为改为false)。程序最终的状态取决于catch部分代码，可以忽略这个异常，也可以跳出循环结束线程。

你能说一下线程的状态都有哪些？分别表示什么意义

//观察线程的所有状态
public class ThreadState{
	public static void main(String[] args) {
        for(Thread.State state : Thread.State.values()){
            System.out.println(state);
        }
    }
}

• NEW: 安排了工作, 还未开始行动 ，Thread对象已经创建，还未分配PCB
• RUNNABLE: 可工作的. 又可以分成正在工作中和即将开始工作，PCB已创建，随时待命
• BLOCKED: 排队等着其他事情，线程中尝试加锁，发现锁以被其他线程占用，阻塞等待(释放锁之后唤醒)
• WAITING: 排队等着其他事情，线程调用了wait()方法，阻塞等待
• TIMED_WAITING: 排队等着其他事情，表明当前PCB在阻塞队列中等待，有结束时间
• TERMINATED: 工作完成了，PCB结束了，Thread对象还在,GC回收
  
  借用网图仅供理解（狗头保命）
  注：yield()方法：让线程主动让出CPU，不改变线程的状态（重新排队）

多线程可能会带来什么风险？为什么？简单说说~

多线程可能会产生线程不安全，首先我们应该明确线程安全的概念是什么？

public class Counter {
    public int count = 0;
    void increase() {
        count++;
    }

    public static void main(String[] args) throws InterruptedException {
        final Counter counter = new Counter();
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
                counter.increase();
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
                counter.increase();
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(counter.count);
    }
}
//运行结果每次都不一样！

不管是在单线程，还是在多线程环境下运行，我们期望程序运行的结果都是一致的。就说明该线程是安全的。
导致线程不安全的原因有：
① 线程之间抢占式执行方式（根本原因）
线程和线程之间的执行顺序是不可控的，取决于操作系统资源调度器自身的实现，线程内部操作具有一定的随机性。

② 多个线程修改同一个变量
上述代码中，运行结果每次都不一样。主要是因为涉及到多个线程针对counter.count变量进行修改，count变量在堆上，因此可以被多个线程共享访问。

tips:Test t = new Test();
new 一个对象时，此时对象放在heap中，t放在stack中

③ 不保证原子性
原子性：同步互斥，各操作视为一个整体，不可分。
i++操作为例：我们所看到的的一行代码，其实有三部分组成：
a. 从内存中把数据读到CPU
b. 进行数据更新
c. 把数据写回至CPU
以上就是非原子性的操作，如果线程正在对一个变量操作，中途其他线程插进来了，可能会造成线程不安全现象。

④ 不保证内存可见性
可见性是指, 一个线程对共享变量值的修改，能够及时地被其他线程看到。

线程之间的共享变量存在 主内存 (Main Memory)中；
每一个线程都有自己的 “工作内存” (Working Memory) ；
当线程要读取一个共享变量的时候, 会先把变量从主内存拷贝到工作内存, 再从工作内存读取数据；
当线程要修改一个共享变量的时候, 也会先修改工作内存中的副本, 再同步回主内存。

由于每个线程有自己的工作内存, 这些工作内存中的内容相当于同一个共享变量的 “副本”. 此时修改一个线程 的工作内存中的值, 另一个线程的工作内存不一定会及时变化。
由于编译器的优化，可能会把一些中间环节省略掉，此时读的线程可能是未被修改的结果。
注意：在单线程下，这样的优化方案没有任何问题，但是在多线程下就有可能发生线程不安全的现象。
那么，你可能会问，为什么我们要整这么多内存？并且要这么麻烦的拷来拷去呢？
“主内存”是真正意义上的内存，所谓的“工作内存”则是CPU的寄存器和高速缓存。因为CPU访问自身寄存器/高速缓存的速度，远远超过访问内存的速度，这样读取效率会大大提升。

⑤ 指令重排序
同样与编译器优化有关，编译器会自动调整指令的执行顺序，以提高执行效率。

如有错误！请批评指正！