前言：

我们再看线程之前肯定已经学了一个东西叫做进程，进程同线程一样都可以在系统cpu上去调度执行，那为啥有了进程，我们还要学习线程呢？？这是因为计算机是实行并发编程的，每次进程在去系统api上调度执行的时候，系统都会重新为其分配系统资源，这也有了一个概念：进程是资源分配的基本单位，这样如果实行多进程编程的时候，系统创建/调度/销毁进程的效率就会变成很慢，这也是它重量级进程名字的来源！！所以这才有了线程！！

1.进程的缺点和线程的优点（相比较于进程）

进程的缺点主要是体现在多进程编程的时候，现有如下一个例子：

有一个工厂只有一条生产线，现在它的产品买的火爆，需要扩大生产，这时候该怎么做呢？？

法一：在找一块地，然后再在原来基础开辟一条生产线 ==>  多进程

法二：再在原来的工厂增加一条生产线  ==> 多线程

相比较于法一，法二的方式，更加符合实际生存需求，法一所消耗的人力，物力，和空间都是原来的一赔，而法二只需要物力（再增加一条生产线）。法二体现的思想就是多线程的思想。

所以进程相较与线程更“笨重”，也就为重量级线程，而线程为轻量级进程！！

2.线程（轻量级进程，Thread）

（1）线程的特点：

a.每个线程都可以独立地去CPU上调度执行。

b.线程是不能独立存在的，它是依附于进程的，进程包含线程（可以有一个线程，也可以有多个线程）。

c.同一个进程中的不同线程共用同一份内存空间和文件资源（硬盘资源）（不同线程在同一个进程中创建是会直接复用之前系统分配给进程的资源（内存 + 硬盘），于是创建的效率更高）

d.线程是调度执行的基本单位，是轻量级进程。

3.进程与线程的区别：

a.进程是资源分配的基本单位，而线程是调度执行的基本单位。

b.包含关系：进程包含线程，一个进程里面可以有一个线程，也可以有多个

c.进程与进程之前是相互独立的，因为每个进程在创建的时候都会向系统申请资源（内存+硬盘），这个过程效率是低下的！！

d.同一个进程的不同线程之前的关系是相互影响，因为它们共用同一份内存空间和文件标识符，每次创建一个线程时都不用向系统申请资源，会复原之前分配给进程的资源，这个过程效率是高效的！！

4.Thread类（线程）

Thread类是java标准内置库中的类，在java.lang（String也在这个包中）这个包中，该包是不需要导入的！！

（1）创建一个线程（创建一个Thread类）

a.继承Thread类：

Thread t2 = new MyThread();  java里面推荐向上转型的写法

class MyThread extends Thread {
    @Override
    public void run() {
        while(true) {
            System.out.println("我的线程启动");
            //在Thread类的源代码中查看sleep方法
            //是一个静态方法且调用可能会抛出异常，所以必须要显示处理
            try {
                Thread.sleep(1000); //表示休眠1000ms（1s）
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }

    }
}

b.实现Runnable接口

Runnable接口中有run方法所以必须要重写！！使用Runnable接口的写法与直接继承Thread之间的区别是：前者能够解耦合（进程与任务之间无太大的关系，任务由谁来执行，并无指定的进程，应尽量使用）。Runnable表示的是一个可以执行的任务，这个任务交给进程还是其他实体执行，Runnable本身并不关心，当一个任务必须交给某个进程执行的时候，此时就表示进程与任务具有一定的耦合关系。

Runnable r = new MyRunnable();

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("我的任务！！");
    }
    
}

c.使用匿名内部类创建线程：

//普通的匿名内部类创建方法
Thread t1 = new Thread() {
    @Override
    public void run() {
        System.out.println("线程t1启动");
    } 
};

//带Runnable的匿名内部类创建方法        
Thread t2 = new Thread(new Runnable() {
            
    @Override
    public void run() {
        System.out.println("t2");
    }
});

d.使用lambda表达式 （最常用）

本质上是一个匿名函数（用一次就完了），主要用来实现回调函数的效果，且使用lambda表达式不需要重写run方法（因为其本身就是run方法，是线程的入口）

Thread t = new Thread( () -> {

          ...........

});

（2）Thread的构造方法：

a.Thread（）：无参构造

b.Thread（Runnable target）：使用Runnable构造

c.Thread（String name）：创建线程，并取名

d.Thread（Runnable target， String name）

Thread t3 = new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("t3线程");
    }
}, "新线程");

（3）Thread类的一些属性：

a.ID ==> getId() :线程的身份标识（不是系统api提供的id也不是PCB的id）

b.名称 ==> getName()

c.状态 ==> getState()

d.优先级 ==> getPriority() :优先级高理论上会更容易被调用，这个过程在是“微观的”，我们人是觉  不出来的，我们只会感觉是同时进行的，但在计算机上优先级高的先被调用

e.是否为后台线程 ==> isDamon() :后台线程对于整个线程的结束是没有影响的，但是前台线程是有影响的！！默认下一个线程是前台线程。可以通过setDamon(boolean b)的方式来设置当前线程是否为什么线程！！

f.是否存活 ==> isAlive() ：线程在未启动前是false，启动了之后就是true，当整个线程已经执行完毕，但Thread对象还在此时就是false！！

g.是否被中断 ==> isInterrupted()：通过Thread.currentThread().isInterrupted()来判断当前线程四否被中断（Thread类中有一个标志位，其可以用来判定线程是否结束。可以通过interrupted方法来中断当前的线程，将其标志位设置为true），其中Thread.currentThread()获取到当前线程的实例（谁调用currentThread方法就获取到谁的一个线程实例）。

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

    Thread t4  = new Thread(() -> {
        while(!Thread.currentThread().isInterrupted()) {
            System.out.println("线程开始工作");
            try {
                Thread.sleep(1000);
            }catch (InterruptedException e) {
                //1.假装没看见，继续循环
                //e.printStackTrace();
                //2.加一个break跳出循环
                //e.printStackTrace();
                //break;
                //3.其他操作
                //e.printStackTrace();
                //其他操作
                //break;
                   
            }
        }
    });
    t4.start();
    Thread.sleep(2000);
    System.out.println("让线程终止");
    t4.interrupt();
}

上述代码的运行结果为：

正常来说sleep会休眠时间到才能被唤醒，此处给的interrupted方法可以让sleep内部触发一个异常，从而提前被唤醒。当interrupted唤醒线程之后，此时sleep方法抛出异常，同时会自动清除刚才的标志位（最初为false，然后当调用interrupted方法后标志位会被设置为true，然后接下来true会被清除，标志位重新被设置为false，所以如果在抛出异常后不在捕获中进行处理的话就会一直循环）。所以当线程接受到“要中断”这样的信号的时候，能够自由决定，接下来怎么处理让我们有更多操作的可能（捕获里进行操作） ==>  前提是通过“异常”的方式唤醒。

（4）线程的等待：

让一个线程，等待另一个线程执行结束，再继续执行 ==> join实现线程等待

ps：主线程中，调用t.join()就是让主线程等待t线程运行结束

t.join的工作过程：

1）如果t线程正在运行过程中，此时调用join方法线程就会阻塞直到t线程运行结束为止

2）如果t线程已经执行结束，此时调用join方法线程就直接返回了，不会涉及到阻塞

（5）线程的状态：

NEW：Thread对象已经有了，但还没有被调用

TERMINATED：Thread对象还在，但内核中的线程已经没了

RUNNABLE：就绪状态（线程已经在cpu上去调度执行了/正在排队等待准备去cpu上执行）

TIMED_WAITING：阻塞，由于sleep这种固定时间的方式所产生的阻塞

WAITING：阻塞，由于wait这种不固定时间的方式所产生的阻塞

BLOCKED：阻塞，由于锁竞争导致的阻塞

（6）线程的安全问题：

先来看下面一段代码：

该段代码的运行结果为：（我们的预期结果为100000，但是可以看见每次的运行结果都不相同，并且结果也不是预期的结果，数值的范围：0~100000）

产生上述问题的原因：多线程之间的调度是随机的，在这个实例代码中t1和t2线程会穿插执行，

也就是如下的情况：

总结线程产生安全问题的原因：

a.操作系统中，多个线程之间的调度顺序是随机的（抢占式执行）

b.两个线程，对同一个变量修改（两个线程同时读一个变量/两个线程同时对两个变量进行修改/一个线程对一个变量进行修改）

c.修改操作不是原子的，这是的count++就是非原子操作，分成了三个指令去完成，要让count++的操作变成原子的，一个指令 ==>需要进行加锁！！

d.内存可见性问题

e.指令重排序问题