【学习笔记】Java基础知识点——第10章·多线程

本文链接：https://blog.csdn.net/qq_45957915/article/details/119498012

第10章多线程

10.1 多线程的基本概念

线程指进程中的一个执行场景，也就是执行流程，那么进程和线程有什么区别呢？

每个进程是一个应用程序，都有独立的内存空间（例如，QQ进程，LOL进程）。
同一个进程中的线程共享其进程中的内存和资源（共享的内存是堆内存和方法区内存，栈内存不共享，每个线程有自己的）。

什么是真正的多线程并发？

t1线程执行t1的。
t2线程执行t2的。
t1不会影响t2，t2也不会影响t1。这叫做真正的多线程并发。

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

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

线程A（播放QQ音乐）和线程B（打LOL）频繁切换执行，人类会感觉音乐一直在播放，游戏一直在运行，给我们的感觉是同时并发的。

10.2 线程的创建与启动

10.2.1 直接继承java.lang.Thread

public class ThreadTest02 {
    public static void main(String[] args) {
        // 这里是main方法，这里的代码属于主线程，在主栈中运行。
        // 新建一个分支线程对象
        MyThread t = new MyThread();
        // 启动线程
        //t.run(); // 不会启动线程，不会分配新的分支栈。（这种方式就是单线程。）
        // start()方法的作用是：启动一个分支线程，在JVM中开辟一个新的栈空间，这段代码任务完成之后，瞬间就结束了。
        // 这段代码的任务只是为了开启一个新的栈空间，只要新的栈空间开出来，start()方法就结束了。线程就启动成功了。
        // 启动成功的线程会自动调用run方法，并且run方法在分支栈的栈底部（压栈）。
        // run方法在分支栈的栈底部，main方法在主栈的栈底部。run和main是平级的。
        t.start();
        // 这里的代码还是运行在主线程中。
        for(int i = 0; i < 1000; i++){
            System.out.println("主线程--->" + i);
        }
    }
}

class MyThread extends Thread {
    @Override
    public void run() {
        // 编写程序，这段程序运行在分支线程中（分支栈）。
        for(int i = 0; i < 1000; i++){
            System.out.println("分支线程--->" + i);
        }
    }
}

10.2.2 实现java.lang.Runnable接口

public class ThreadTest03 {
    public static void main(String[] args) {
        // 创建一个可运行的对象
        //MyRunnable r = new MyRunnable();
        // 将可运行的对象封装成一个线程对象
        //Thread t = new Thread(r);
        Thread t = new Thread(new MyRunnable());         
        t.start();
        for(int i = 0; i < 100; i++){
            System.out.println("主线程--->" + i);
        }
    }
}
// 这并不是一个线程类，是一个可运行的类。它还不是一个线程。
class MyRunnable implements Runnable {
    @Override
    public void run() {
        for(int i = 0; i < 100; i++){
            System.out.println("分支线程--->" + i);
        }
    }
}

同时，该方法也可以采用“匿名内部类”的方式进行实现：

public class ThreadTest04 {
    public static void main(String[] args) {
        // 创建线程对象，采用匿名内部类方式。
        // 这是通过一个没有名字的类，new出来的对象。
        Thread t = new Thread(new Runnable(){
            @Override
            public void run() {
                for(int i = 0; i < 100; i++){
                    System.out.println("t线程---> " + i);
                }
            }
        });
        // 启动线程
        t.start();
        for(int i = 0; i < 100; i++){
            System.out.println("main线程---> " + i);
        }
    }
}

10.2.3 实现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!");
    }
}

10.3 线程的生命周期

新建：采用 new语句创建完成

就绪：执行 start 后

运行：占用 CPU 时间

阻塞：执行了 wait 语句、执行了 sleep 语句和等待某个对象锁，等待输入的场合

终止：退出 run()方法

10.4 线程的调度与控制（了解）

10.4.1 常见的线程调度模型

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

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

10.4.2 与线程调度有关的方法

1.实例方法：setPriority与getPriority方法

void setPriority(int newPriority) 设置线程的优先级。

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

2.静态方法：yield方法

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

3.实例方法：join方法

void join() 合并线程。

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

10.5 线程的常用方法

10.5.1 获取线程

获取当前线程对象：Thread t = Thread.currentThread();
获取线程对象的名字：String name = t.getName();
修改线程对象的名字：t.setName("线程名字");

10.5.2 sleep方法

1.static void sleep(long millis)

静态方法：Thread.sleep(1000);
参数是毫秒。
作用：让当前线程进入休眠，进入“阻塞状态”，放弃占有CPU时间片，让给其它线程使用。
Thread.sleep()方法，可以做到这种效果：间隔特定的时间，去执行一段特定的代码，每隔多久执行一次。

2.void interrupt() 中断这个线程。

使用如下的方法关闭线程：（stop方法已过时，易造成用户数据丢失）

public class ThreadTest10 {
    public static void main(String[] args) {
        MyRunable4 r = new MyRunable4();
        Thread t = new Thread(r);
        t.setName("t");
        t.start();
        // 模拟5秒
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 终止线程,想要什么时候终止t的执行，那么你把标记修改为false，就结束了。
        r.run = false;
    }
}

class MyRunable4 implements Runnable {
    // 打一个布尔标记
    boolean run = true;
    @Override
    public void run() {
        for (int i = 0; i < 10; i++){
            if(run){
                System.out.println(Thread.currentThread().getName() + "--->" + i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }else{
                // return就结束了，你在结束之前还有什么没保存的。在这里可以保存呀。
                //终止当前线程
                return;
            }
        }
    }
}

10.6 线程安全

10.6.1 存在线程安全问题的3个条件

多线程并发；
有共享数据；
共享数据有修改的行为。

10.6.2 线程同步

线程排队执行（不能并发）。用排队执行解决线程安全问题，这种机制被称为：线程同步机制。线程同步就是线程排队了，线程排队了就会牺牲一部分效率，没办法，数据安全第一位，只有数据安全了，我们才可以谈效率。数据不安全，没有效率的事儿。

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

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

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

10.6.3 Java中的三大变量

实例变量：在堆中。实例变量在堆中，堆只有1个。

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

局部变量：在栈中。局部变量永远都不会存在线程安全问题。因为局部变量不共享（一个线程一个栈。）局部变量在栈中，所以局部变量永远都不会共享。局部变量+常量：不会有线程安全问题。

成员变量：可能会有线程安全问题。

10.6.4 synchronized方法

synchronized有三种写法：

①同步代码块：线程同步机制的语法是：

synchronized(){

// 线程同步代码块。

}

synchronized后面小括号中传的这个“数据”是相当关键的。这个数据必须是多线程共享的数据。才能达到多线程排队。

②在实例方法上使用synchronized。表示共享对象一定是this，并且同步代码块是整个方法体。

③在静态方法上使用synchronized。表示找类锁，类锁永远只有1把。就算创建了100个对象，那类锁也只有一把。

以下给出具体的实例代码：

public class Test {
    public static void main(String[] args) {
        // 创建账户对象（只创建1个）
        Account act = new Account("act-001", 10000);
        // 创建两个线程
        Thread t1 = new AccountThread(act);
        Thread t2 = new AccountThread(act);
        // 设置name
        t1.setName("t1");
        t2.setName("t2");
        // 启动线程取款
        t1.start();
        t2.start();
    }
}

创建自定义线程类：

public class AccountThread extends Thread {
    // 两个线程必须共享同一个账户对象。
    private Account act;
    // 通过构造方法传递过来账户对象
    public AccountThread(Account act) {
        this.act = act;
    }
    public void run(){
        // run方法的执行表示取款操作。
        // 假设取款5000
        double money = 5000;
        // 取款
        // 多线程并发执行这个方法。
        act.withdraw(money);
        System.out.println(Thread.currentThread().getName() + "对"+act.getActno()+"取款"+money+"成功，余额" + act.getBalance());
    }
}

Account类：

public class Account {
    private String actno;//称号
    private double balance;//余额
    public Account() {}
    public Account(String actno, double balance) {
        this.actno = actno;
        this.balance = balance;
    }
    public String getActno() {return actno;}
    public void setActno(String actno) {this.actno = actno;}
    public double getBalance() {return balance;}
    public void setBalance(double balance) {this.balance = balance;}
    synchronized (this) { // 这样编写就不安全了。因为obj2不是共享对象。
            double before = this.getBalance();
            double after = before - money;
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            this.setBalance(after);
        }
    /*public synchronized void withdraw(double money){
        double before = this.getBalance(); // 10000
        double after = before - money;
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.setBalance(after);
    }*/
}

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

synchronized会让程序执行效率降低，在不得己的情况下再选择“线程同步机制”。以下有三种方案：

尽量使用局部变量代替“实例变量和静态变量”。
如果必须是实例变量，那么可以考虑创建多个对象，这样实例变量的内存就不共享了（一个线程对应1个对象，100个线程对应100个对象，对象不共享，就没有数据安全问题了）。
如果不能使用局部变量，对象也不能创建多个，这个时候就只能选择synchronized了，线程同步机制。

10.6.5 死锁

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){
            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){

            }
        }
    }
}

假设t1线程先抢到了CPU时间片，t1线程在执行时锁住了o1,随后睡眠1s,这个时候t2线程执行了，锁住了o2，继续执行代码块，只有完整的执行完毕后才会释放锁，但是此时这个o1已经被t1线程锁住了，因此陷入死锁。

10.7 守护线程

t.setDaemon(true); // 启动线程之前，将线程设置为守护线程

java语言中线程分为两大类：

用户线程。
守护线程（后台线程），其中具有代表性的就是：垃圾回收线程（守护线程）。

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

10.8 定时器

public class TimerTest {
    public static void main(String[] args) throws Exception {

        // 创建定时器对象
        Timer timer = new Timer();
        //Timer timer = new Timer(true); //守护线程的方式

        // 指定定时任务
        //timer.schedule(定时任务, 第一次执行时间, 间隔多久执行一次);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date firstTime = sdf.parse("2021-8-8 12:15:30" );

        //匿名内部类方式
        timer.schedule(new TimerTask(){
            @Override
            public void run() {
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                String strTime = sdf.format(new Date());
                System.out.println(strTime + ":成功完成了一次数据备份！");
            }
        } , firstTime, 1000 * 10);
    }
}

10.9 Object类中的wait和notify方法

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

10.9.1 wait方法

Object o = new Object();

o.wait();

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

10.9.2 notify方法

Object o = new Object();

o.notify();

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

10.9.3 生产者和消费者模式

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

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

wait方法作用：o.wait()让正在o对象上活动的线程t进入等待状态，并且释放掉t线程之前占有的o对象的锁。
notify方法作用：o.notify()让正在o对象上等待的线程唤醒，只是通知，不会释放o对象上之前占有的锁。

模拟这样一个需求：仓库我们采用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();
            }
        }
    }
}