老杜多线程（视频索引笔记）

一. 索引知识点

1. 600集：堆和方法区多线程共享，栈独立

（1）多线程堆和方法区只有一个，而栈可以有多个，且栈与栈之间相互独立。

（2）若在主线程main中启动另一个线程m1，此时就会再分配一个栈空间----分支栈。

2. 601集：多线程并发的理解

（1）分析一个问题：对于单核的CPU来说，真的可以做到真正的多线程并发吗？

（2）什么是真正的多线程并发？
t1线程执行t1的。
t2线程执行t2的。
t1不会影响t2，t2也不会影响t1。这叫做真正的多线程并发

（3）单核的CPU表示只有一个大脑：
不能够做到真正的多线程并发，但是可以做到给人一种“多线程并发”的感觉。
对于单核的CPU来说，在某一个时间点上实际上只能处理一件事情，但是由于
CPU的处理速度极快，多个线程之间频繁切换执行，跟人来的感觉是：多个事情
同时在做。

（4）电影院采用胶卷播放电影，一个胶卷一个胶卷播放速度达到一定程度之后，
人类的眼睛产生了错觉，感觉是动画的。这说明人类的反应速度很慢，就像
一根钢针扎到手上，到最终感觉到疼，这个过程是需要“很长的”时间的，在
这个期间计算机可以进行亿万次的循环。所以计算机的执行速度很快。

（5）对于多核的CPU电脑来说，真正的多线程并发是没问题的。
4核CPU表示同一个时间点上，可以真正的有4个进程并发执行。

3. 602集：分析程序存在几个线程

​ 一个线程对应一个栈。

4. 603集：实现线程的第一种方式

​ 略，请在老杜32笔记中查看

（1）start()方法作用：

​ 1）启动一个分支线程，在JVM中开辟一个新的栈空间，这段代码的任务完成之后，瞬间就结束了。

​ 2）不会阻塞后面代码的执行。所以并发。

​ 3）只要新的栈空间开辟出来，start方法就结束了。线程就启动成功

（2）run方法：

​ 1）启动成功的线程会自动调用run方法，并且run方法在分支栈的栈底部（压栈）。

​ 2）run方法在分支栈的底部，main方法在主栈的栈底部。run和main方法是平级的。

（3）可不可以直接在main方法中调用run方法，不用start()方法？

​ 1）不行。亘古不变的道理：方法体当中的代码永远都是按自上而下的顺序依次逐行执行的

​ 2）倘若替换，要等待run方法执行完毕后，再执行后面的代码，不会出现多线程。

5. 604集：run()和start()方法的区别

run方法由JVM线程调度机制自动调用。

6. 605集：第二种方式

略

两种方式比较：第二种方式面向接口，实现接口比较常用，因为一个类实现了接口，它还可以去继承其它的类，更灵活。

7. 606集：匿名内部类

8. 607集：线程生命周期

（1）关于线程对象的生命周期？
新建状态
就绪状态
运行状态
阻塞状态：如Scanner()用户输入等。
死亡状态

（2）不断在就绪状态和运行状态左右横跳，形成多线程的错觉。

9. 610集：获取当前线程对象

（1）如何获取当前线程对象？

Thread t = Thread.currentThread(); //返回值t就是当前线程

（2）获取线程对象的名字

Thread t = 线程对象.getName();

（3）修改线程对象的名字

线程对象.setName("线程名字");

默认名称规律：Thread-0，Thread-1，Thread-2等

10. 611集：线程的sleep()方法

static void sleep(毫秒)；静态方法。

作用：让当前线程进入休眠，进入“阻塞状态”，放弃占有CPU时间片，让给其他线程使用。

注意：出现在哪个线程，哪个线程休眠。如：在主线程中调用其他线程的sleep方法，同样是主线程休眠。如下

11. 612集：sleep方法面试题

main方法{
    Thread t = new MyThread();
    t.setName("t");
    t.start();
    t.sleep(毫秒); //问这行代码会让线程t进入休眠状态吗?
    			 //不会
    			 //为什么？
    			 //在执行的时候还是会转换成：Thread.sleep(毫秒)；这涉及到static关键字，自行补习
}

MyThread extends Thread{}

12. 613集：终止线程的睡眠

线程对象.interrupt()方法 //干扰，一盆冷水泼过去。

try···catch(){当此线程对象打印错误信息时，会报出异常信息，但是达到了终止睡眠的目的，不想打印这里不写即可}

13. 614集：强行终止线程（不建议 ）

线程对象.start();

缺点：容易丢失数据。应为这种方式是直接将程序杀死了，线程没有保存的数据会丢失，不建议使用。

14. 615集：合理终止一个线程的执行。

main主线程{
	t.run = false;
}

t线程{
    if(run){
        Thread.sleep(毫秒);
    }else{
       //这里可以保存数据
        return;
   }
}

15. 616集：线程调度概述

常见的线程调度模型有哪些？

（1）抢占式调度模型：
那个线程的优先级比较高，抢到的CPU时间片的概率就高一些/多一些。
java采用的就是抢占式调度模型。

（2）均分式调度模型：
平均分配CPU时间片。每个线程占有的CPU时间片时间长度一样。
平均分配，一切平等。
有一些编程语言，线程调度模型采用的是这种方式。

16. 617集：线程调度的方法

java中提供了哪些方法是和线程调度有关系的呢？

（1）实例方法：
void setPriority(int newPriority) 设置线程的优先级
int getPriority() 获取线程优先级
最低优先级1
默认优先级是5
最高优先级10
优先级比较高的获取CPU时间片可能会多一些。（但也不完全是，大概率是多的。）

（2）静态方法：
static void yield() 让位方法
暂停当前正在执行的线程对象，并执行其他线程
yield()方法不是阻塞方法。让当前线程让位，让给其它线程使用。
yield()方法的执行会让当前线程从“运行状态”回到“就绪状态”。
注意：在回到就绪之后，有可能还会再次抢到。

（3）实例方法：
void join()
合并线程
class MyThread1 extends Thread {
public void doSome(){
MyThread2 t = new MyThread2();
t.join(); // 当前线程进入阻塞，t线程执行，直到t线程结束。当前线程才可以继续。
}
}

class MyThread2 extends Thread{}

线程合并不是合并栈，是栈之间协调了。如上：等到t线程结束。当前线程才可以继续。

17. 618,619,620集：上面三种方法的演示用法

18. 621集：线程安全是重点

​ 为什么这个是重点？
​ （1）以后在开发中，我们的项目都是运行在服务器当中，而服务器已经将线程的定义，线程对象的创建，线程的启动等，都已经实 现完了。这些代码我们都不需要编写。

​ （2）最重要的是：你要知道，你编写的程序需要放到一个多线程的环境下运行，你更需要关注的是这些数据在多线程并发的环境下 是否是安全的。（重点：*****）

19. 622集：线程不安全的条件

​ 什么时候数据在多线程并发的环境下会存在安全问题呢？
​ 三个条件：
​ （1）条件1：多线程并发。
​ （2）条件2：有共享数据。
​ （3）条件3：共享数据有修改的行为。

​ 满足以上3个条件之后，就会存在线程安全问题。

20. 623集：怎么解决线程安全问题？

（1）怎么解决线程安全问题呢？
当多线程并发的环境下，有共享数据，并且这个数据还会被修改，此时就存在线程安全问题，怎么解决这个问题？
1）线程排队执行。（不能并发）。
2）用排队执行解决线程安全问题。
3）这种机制被称为：线程同步机制。

（2）专业术语叫做：线程同步，实际上就是线程不能并发了，线程必须排队执行。
怎么解决线程安全问题呀？
使用“线程同步机制”。

（3）线程同步就是线程排队了，线程排队了就会牺牲一部分效率，没办法，数据安全第一位，只有数据安全了，我们才可以谈效率。数据不安全，没有效率的事儿。

21. 624集：同步和异步的理解

说到线程同步这块，涉及到这两个专业术语：

（1）异步编程模型：
线程t1和线程t2，各自执行各自的，t1不管t2，t2不管t1，谁也不需要等谁，这种编程模型叫做：异步编程模型。其实就是：多线程并发（效率较高。）

• 异步就是并发。

（2）同步编程模型：
线程t1和线程t2，在线程t1执行的时候，必须等待t2线程执行结束，或者说在t2线程执行的时候，必须等待t1线程执行结束，两个线程之间发生了等待关系，这就是同步编程模型。效率较低。线程排队执行。

• 同步就是排队。

22. 625，626集：账户异步项目演示：

（1）环境：

​ 1）一个张户类，一个线程类，一个main函数

​ 2）main函数中创建两个线程对象

​ 3）另外还在账户类更新账户方法之前调用sleep()静态方法，以保证一定出错

（2）结果：数据不不同步

23. 627集：同步代码块synchronized

由此引出同步代码块synchronized

位置：账户类的取款方法

//()这个对象必须是多线程共享的，才能达到多线程排队
//在这里用的this,因为这个方法是在账户类中，碰巧而已
用法：synchronized(线程共享的对象){
	//这里封装要同步的方法中的代码
}

24. 628集：对synchronized的理解

（1）synchronized相当于一个把厕所的锁，进来把门锁上，等结束才让第二个人进来，第二个人又得把门锁上······

​ 这个共享对象，就相当于这个厕所坑位。。。

（2）
（3）在java语言中，任何一个对象都有“一把锁”，其实这把锁就是标记。（只是把它叫做锁。）
100个对象，100把锁。1个对象1把锁。

（4）代码的执行原理？
1）假设t1和t2线程并发，开始执行以下代码的时候，肯定有一个先一个后。
2）假设t1先执行了，遇到了synchronized，这个时候自动找“后面共享对象”的对象锁，找到之后，并占有这把锁，然后执行同 步代码块中的程序，在程序执行过程中一直都是占有这把锁的。直到同步代码块代码结束，这把锁才会释放。
3）假设t1已经占有这把锁，此时t2也遇到synchronized关键字，也会去占有后面共享对象的这把锁，结果这把锁被t1占有，t2只 能在同步代码块外面等待t1的结束， 直到t1把同步代码块执行结束了，t1会归还这把锁，此时t2终于等到这把锁，然后t2占 有这把锁之后，进入同步代码块执行程序。

​ 这样就达到了线程排队执行。这里需要注意的是：这个共享对象一定要选好了。这个共享对象一定是你需要排队执行的这些线程对象所共享的。

25. 630集：哪些变量有线程安全问题？

（1）Java中有三大变量？【重要的内容。】

​ 1）实例变量：在堆中。

​ 2）静态变量：在方法区。

​ 3）局部变量：在栈中。

（2）以上三大变量中：
1）局部变量永远都不会存在线程安全问题。
2）因为局部变量不共享。（一个线程一个栈。第622集说明了多项成不安全的三个条件）
3）局部变量在栈中。所以局部变量永远都不会共享。

（3）实例变量在堆中，堆只有1个。静态变量在方法区中，方法区只有1个。
堆和方法区都是多线程共享的，所以可能存在线程安全问题。

（4）局部变量+常量：不会有线程安全问题。
成员变量：可能会有线程安全问题。

26. 632集：synchronized出现在实例方法上（关键字）

（1）在实例方法上可以使用synchronized吗？可以的。
synchronized出现在实例方法上，一定锁的是this。
没得挑。只能是this。不能是其他的对象了。

（2）缺点：1）所以这种方式不灵活。

​ 2）另外还有一个缺点：synchronized出现在实例方法上，表示整个方法体都需要同步，可能会无故扩大同步的
​ 范围，导致程序的执行效率降低。所以这种方式不常用。

（3）优点：代码写的少了。节俭了。 如果共享的对象就是this，并且需要同步的代码块是整个方法体，
建议使用这种方式。

26. 633集：synchronized的三种写法：

synchronized有三种写法：

（1）第一种：同步代码块
灵活
synchronized(线程共享对象){
同步代码块;
}

（2）第二种：在实例方法上使用synchronized
表示共享对象一定是this
并且同步代码块是整个方法体。

（3）第三种：在静态方法上使用synchronized（这节课重点）
表示找类锁。
类锁永远只有1把。
就算创建了100个对象，那类锁也只有一把。

对象锁：1个对象1把锁，100个对象100把锁。类锁：100个对象，也可能只是1把类锁。

27. 634~637集：synchronized面试题

自行看视频

根本：判断两个方法中synchronized是否锁住的是同一个对象。

28. 638集：死锁

源码：（可能会让写源码）

结论：synchronized在开发中最好不要嵌套使用。

/*
死锁代码要会写。
一般面试官要求你会写。
只有会写的，才会在以后的开发中注意这个事儿。
因为死锁很难调试。
 */
public class DeadLock {
    public static void main(String[] args) {
        Object o1 = new Object();
        Object o2 = new Object();

        // t1和t2两个线程共享o1,o2
        Thread t1 = new MyThread1(o1,o2);
        Thread t2 = new MyThread2(o1,o2);

        t1.start();
        t2.start();
    }
}
class MyThread1 extends Thread{
    Object o1;
    Object o2;
    public MyThread1(Object o1,Object o2){
        this.o1 = o1;
        this.o2 = o2;
    }
    public void run(){
        synchronized (o1){
            //当没有sleep函数时，有可能不出现死锁现象
            //有的话必然出现
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (o2){
            }
        }
    }
}
class MyThread2 extends Thread {
    Object o1;
    Object o2;
    public MyThread2(Object o1,Object o2){
        this.o1 = o1;
        this.o2 = o2;
    }
    public void run(){
        synchronized (o2){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (o1){
            }
        }
    }
}

29. 639集：开发中应该怎么解决线程安全问题？

（1）是一上来就选择线程同步吗？synchronized
不是，synchronized会让程序的执行效率降低，用户体验不好。
系统的用户吞吐量（并发量）降低。用户体验差。在不得已的情况下再选择线程同步机制。
（2）不使用synchronized，那我们应该如何应对呢？两种方案

​ 1）第一种方案：尽量使用局部变量代替“实例变量和静态变量”。

​ 2）第二种方案（第636集：面试题3，锁住的对象不一样）：如果必须是实例变量，那么可以考虑创建多个对象，这样实例变量的内存就不共享了。（一个线程对应1个对象，100个线程对应100个对象，对象不共享，就没有数据安全问题了。）

​ 3）第三种方案：如果不能使用局部变量，对象也不能创建多个，这个时候就只能选择synchronized了。线程同步机制。

30. 642集：实现守护线程

如何将普通线程变成守护线程？

在启动线程之前加上这行代码，将线程设置为守护线程------->线程对象.setDaemon(true);

老杜守护线程笔记=====

（1）java语言中线程分为两大类：
一类是：用户线程
一类是：守护线程（后台线程）
其中具有代表性的就是：垃圾回收线程（守护线程）。

（2）守护线程的特点：
一般守护线程是一个死循环，所有的用户线程只要结束，守护线程自动结束。

（3）注意：主线程main方法是一个用户线程。

（4）守护线程用在什么地方呢？
每天00:00的时候系统数据自动备份。
这个需要使用到定时器，并且我们可以将定时器设置为守护线程。
一直在那里看着，没到00:00的时候就备份一次。所有的用户线程
如果结束了，守护线程自动退出，没有必要进行数据备份了。

31. 643集：定时器概述

（1）定时器的作用：

​ 1）间隔特定的时间，执行特定的程序。

​ 2）每周要进行银行账户的总账操作。每天要进行数据的备份操作。

（2）在实际的开发中，每隔多久执行一段特定的程序，这种需求是很常见的，那么在java中其实可以采用多种方式实现：

​ 1）可以使用sleep方法，睡眠，设置睡眠时间，没到这个时间点醒来，执行任务。这种方式是最原始的定时器。（比较low）

​ 2）在java的类库中已经写好了一个定时器：java.util.Timer，可以直接拿来用。不过，这种方式在目前的开发中也很少用，因为现在 有很多高级框架都是支持定时任务的。

​ 3）在实际的开发中，目前使用较多的是Spring框架中提供的SpringTask框架，这个框架只要进行简单的配置，就可以完成定时器的 任务。（SpringTask框架底层使用java.util.Timer）

31. 644集：实现定时器

​ 先略过

32. 645集：实现线程的第三种方式

（1）如何实现？

​ 1）创建类实现Callable接口

​ 2）创建一个“未来任务类”对象，参数是Callable接口实现类对象

​ 3）将未来任务类对象作为参数传入创建的Thread类的构造方法中如下

（1）如何获取返回值？

​ Object obj = 未来任务类对象.get();

（2）优缺点：

​ 1）优点：可以获取到线程的执行结果。

​ 2）缺点：效率比较低，在获取t线程执行结果的时候，当前线程受阻塞，效率较低。

package com.bjpowernode.java.thread;

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask; // JUC包下的，属于java的并发包，老JDK中没有这个包。新特性。

/*
实现线程的第三种方式：
    实现Callable接口
    这种方式的优点：可以获取到线程的执行结果。
    这种方式的缺点：效率比较低，在获取t线程执行结果的时候，当前线程受阻塞，效率较低。
 */
public class ThreadTest15 {
    public static void main(String[] args) throws Exception {

        // 第一步：创建一个“未来任务类”对象。
        // 参数非常重要，需要给一个Callable接口实现类对象。
        FutureTask task = new FutureTask(new Callable() {
            @Override
            public Object call() throws Exception { // call()方法就相当于run方法。只不过这个有返回值
                // 线程执行一个任务，执行之后可能会有一个执行结果
                // 模拟执行
                System.out.println("call method begin");
                Thread.sleep(1000 * 10);
                System.out.println("call method end!");
                int a = 100;
                int b = 200;
                return a + b; //自动装箱(300结果变成Integer)
            }
        });

        // 创建线程对象
        Thread t = new Thread(task);

        // 启动线程
        t.start();

        // 这里是main方法，这是在主线程中。
        // 在主线程中，怎么获取t线程的返回结果？
        // get()方法的执行会导致“当前线程阻塞”
        Object obj = task.get();
        System.out.println("线程执行结果:" + obj);

        // main方法这里的程序要想执行必须等待get()方法的结束
        // 而get()方法可能需要很久。因为get()方法是为了拿另一个线程的执行结果
        // 另一个线程执行是需要时间的。
        System.out.println("hello world!");
    }
}

=老杜笔记：====

（1）实现线程的第三种方式：实现Callable接口。（JDK8新特性。）
这种方式实现的线程可以获取线程的返回值。
之前讲解的那两种方式是无法获取线程返回值的，因为run方法返回void。

（2）思考：
系统委派一个线程去执行一个任务，该线程执行完任务之后，可能会有一个执行结果，我们怎么能拿到这个执行结果呢？
使用第三种方式：实现Callable接口方式。

33. 646集：wait和notify概述

（1）wait和notify方法不是线程对象的方法，是java中任何一个java对象都有的方法，因为这两个方式是Object类中自带的。
wait方法和notify方法不是通过线程对象调用，不是这样的：t.wait()，也不是这样的：t.notify()…不对。

（2）wait()方法作用？
Object o = new Object();
o.wait();

​ 表示：
​ 让正在o对象上活动的线程进入等待状态，无期限等待，
​ 直到被唤醒为止。
​ o.wait();方法的调用，会让“当前线程（正在o对象上
​ 活动的线程）”进入等待状态

（3）notify()方法作用？
Object o = new Object();
o.notify();

​ 表示：
​ 唤醒正在o对象上等待的线程。
​ 还有一个notifyAll()方法：
​ 这个方法是唤醒o对象上处于等待的所有线程。

34. 647集：生产者和消费者模式

35. 648集：实现生产者和消费者模式

package com.bjpowernode.java.thread;

import java.util.ArrayList;
import java.util.List;

/*
1、使用wait方法和notify方法实现“生产者和消费者模式”

2、什么是“生产者和消费者模式”？
    生产线程负责生产，消费线程负责消费。
    生产线程和消费线程要达到均衡。
    这是一种特殊的业务需求，在这种特殊的情况下需要使用wait方法和notify方法。

3、wait和notify方法不是线程对象的方法，是普通java对象都有的方法。

4、wait方法和notify方法建立在线程同步的基础之上。因为多线程要同时操作一个仓库。有线程安全问题。

5、wait方法作用：o.wait()让正在o对象上活动的线程t进入等待状态，并且释放掉t线程之前占有的o对象的锁。

6、notify方法作用：o.notify()让正在o对象上等待的线程唤醒，只是通知，不会释放o对象上之前占有的锁。

7、模拟这样一个需求：
    仓库我们采用List集合。
    List集合中假设只能存储1个元素。
    1个元素就表示仓库满了。
    如果List集合中元素个数是0，就表示仓库空了。
    保证List集合中永远都是最多存储1个元素。

    必须做到这种效果：生产1个消费1个。
 */
public class ThreadTest16 {
    public static void main(String[] args) {
        // 创建1个仓库对象，共享的。
        List list = new ArrayList();
        // 创建两个线程对象
        // 生产者线程
        Thread t1 = new Thread(new Producer(list));
        // 消费者线程
        Thread t2 = new Thread(new Consumer(list));

        t1.setName("生产者线程");
        t2.setName("消费者线程");

        t1.start();
        t2.start();
    }
}

// 生产线程
class Producer implements Runnable {
    // 仓库
    private List list;

    public Producer(List list) {
        this.list = list;
    }
    @Override
    public void run() {
        // 一直生产（使用死循环来模拟一直生产）
        while(true){
            // 给仓库对象list加锁。
            synchronized (list){
                if(list.size() > 0){ // 大于0，说明仓库中已经有1个元素了。
                    try {
                        // 当前线程进入等待状态，并且释放Producer之前占有的list集合的锁。
                        list.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                // 程序能够执行到这里说明仓库是空的，可以生产
                Object obj = new Object();
                list.add(obj);
                System.out.println(Thread.currentThread().getName() + "--->" + obj);
                // 唤醒消费者进行消费
                list.notifyAll();
            }
        }
    }
}

// 消费线程
class Consumer implements Runnable {
    // 仓库
    private List list;

    public Consumer(List list) {
        this.list = list;
    }

    @Override
    public void run() {
        // 一直消费
        while(true){
            synchronized (list) {
                if(list.size() == 0){
                    try {
                        // 仓库已经空了。
                        // 消费者线程等待，释放掉list集合的锁
                        list.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                // 程序能够执行到此处说明仓库中有数据，进行消费。
                Object obj = list.remove(0);
                System.out.println(Thread.currentThread().getName() + "--->" + obj);
                // 唤醒生产者生产。
                list.notifyAll();
            }
        }
    }
}

项目需求：生产1个消费1个。

此项目演示设计思路：

（1）创建两个类实现Runnable接口（一个生产线程类，一个消费线程类）

run方法{
	while(true){
        synchronized (list) {
            if(判断集合内元素个数){ //为了什么？两个用途：
                				 //1是为了达到需求后跳出死循环，2是为了防止两线程抢占时间片时，再次被该线程抢到
                仓库对象.wait();
            }
            仓库对象.remove(0)/仓库对象.add(new Object());//移除集合内对象/增加元素个数
            sout; //测试打印
            仓库.notifyAll(); //唤醒对象上处于等待的所有线程
        }
    }
}

（2）主线程创建一个仓库（List集合）

（3）主线程创建两个线程对象（生产者线程 和 消费者线程），并创建匿名内部类（其中仓库对象作为匿名内部类的参数）作为 构造函数参数传入两线程中。

（4）开启线程