包子学系列——Java基础第八章_多线程

作者： 作者的头像   cyb-包子 ,  2020-11-01 22:31:47 ,  所有人可见 ,  阅读 820

4


3

第八章 多线程

image-20201101222900624.png

更好的阅读体验

程序、进程、线程

程序(programm)

概念：是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码。

进程(process)

概念：程序的一次执行过程，或是正在运行的一个程序。
说明：进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域

线程(thread)

概念：进程可进一步细化为线程，是一个程序内部的一条执行路径。
说明：线程作为调度和执行的单位，每个线程拥独立的运行栈和程序计数器(pc)，线程切换的开销小。

image-20201101212552207.png

补充

  • 内存结构：

image-20201101212707590.png

进程可以细化为多个线程。
每个线程，拥有自己独立的：栈、程序计数器
多个线程，共享同一个进程中的结构：方法区、堆。

一个Java应用程序java.exe，其实至少有三个线程：main()主线程，gc() 垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。

  • 并行与并发
  • 并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事。
  • 并发：一个CPU(采用时间片)同时执行多个任务。比如：秒杀、多个人做同一件事。

创建多线程的两种方式

方式一：继承Thread类的方式

* 1. 创建一个继承于Thread类的子类
* 2. 重写Thread类的run() --> 将此线程执行的操作声明在run()中
* 3. 创建Thread类的子类的对象
* 4. 通过此对象调用start()：①启动当前线程 ② 调用当前线程的run()

问题一：我们启动一个线程，必须调用start()，不能调用run()的方式启动线程。

问题二：如果再启动一个线程，必须重新创建一个Thread子类的对象，调用此对象的start().

方式二：实现Runnable接口的方式

* 1. 创建一个实现了Runnable接口的类
* 2. 实现类去实现Runnable中的抽象方法：run()
* 3. 创建实现类的对象
* 4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
* 5. 通过Thread类的对象调用start()

两种方式的对比

* 开发中：优先选择：实现Runnable接口的方式
* 原因：1. 实现的方式没类的单继承性的局限性
*      2. 实现的方式更适合来处理多个线程共享数据的情况。
*
* 联系：public class Thread implements Runnable
* 相同点：两种方式都需要重写run(),将线程要执行的逻辑声明在run()中。
          目前两种方式，要想启动线程，都是调用的Thread类中的start()。

JDK5.0 新增线程创建方式

  • 实现Callable接口。 — JDK 5.0新增
  • 使用线程池
package com.atguigu.java2;

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

/*创建多线程的方式：
1.继承Thread
2.实现Runnable
3.实现Callable
4.使用线程池

*/
class MyThread01 extends Thread {
    @Override
    public void run() {
        System.out.println("-----MyThread01");
    }
}

class MyThread02 implements Runnable {
    public void run() {
        System.out.println("-----MyThread02");
    }
}


//新方式
class MyThread03 implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        System.out.println("-----MyThread03");
        return 200;
    }
}

//新方式
public class ThreadNew {
    public static void main(String[] args) {
        new MyThread01().start();
        new Thread(new MyThread02()).start();

        FutureTask<Integer> futureTask = new FutureTask<Integer>(new MyThread03());
        new Thread(futureTask).start();
        try {
            Integer value = futureTask.get();
            System.out.println(value);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

Java中多线程的创建有几种方式？四种。

Thread类的常用方法

* 1. start():启动当前线程；调用当前线程的run()
* 2. run(): 通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
* 3. currentThread():静态方法，返回执行当前代码的线程
* 4. getName():获取当前线程的名字
* 5. setName():设置当前线程的名字
* 6. yield():释放当前cpu的执行权
* 7. join():在线程a中调用线程b的join(),此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态。
* 8. stop():已过时。当执行此方法时，强制结束当前线程。
* 9. sleep(long millitime):让当前线程“睡眠”指定的millitime毫秒。在指定的millitime毫秒时间内，当前线程是阻塞状态。
* 10. isAlive():判断当前线程是否存活

线程优先级

* MAX_PRIORITY：10
* MIN _PRIORITY：1
* NORM_PRIORITY：5  -->默认优先级


//如何获取和设置当前线程的优先级

//getPriority():获取线程的优先级
//setPriority(int p):设置线程的优先级

说明：高优先级的线程要抢占低优先级线程cpu的执行权。但是只是从概率上讲，高优先级的线程高概率的情况下被执行。并不意味着只当高优先级的线程执行完以后，低优先级的线程才执行。

线程通信：wait() / notify() / notifyAll() :此三个方法定义在Object类中的。

线程分类

一种是守护线程，一种是用户线程。

区别是判断JVM何时离开

  • 守护线程是用来服务用户线程的，通过在start()方法前调用 thread.setDaemon(true)可以把一个用户线程变成一个守护线程
  • Java垃圾回收就是一个典型的守护线程
  • 若JVM中都是守护线程，当前JVM将退出。

Thread的生命周期

image-20201101214341984.png

  • 新建： 当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建 状态
  • 就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已 具备了运行的条件，只是没分配到CPU资源
  • 运行：当就绪的线程被调度并获得CPU资源时,便进入运行状态， run()方法定义了线 程的操作和功能
  • 阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中 止自己的执行，进入阻塞状态
  • 死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束

image-20201101214606243.png

线程的同步

问题的引出

例子：创建个窗口卖票，总票数为100张.使用实现Runnable接口的方式

问题：卖票过程中，出现了重票、错票 –>出现了线程的安全问题

问题出现的原因：当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票。

如何解决：当一个线程a在操作ticket的时候，其他线程不能参与进来。直到线程a操作完ticket时，其他线程才可以开始操作ticket。这种情况即使线程a出现了阻塞，也不能被改变。

抽象化

  • 问题的原因：当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有 执行完，另一个线程参与进来执行。导致共享数据的错误。
  • 解决办法：对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以 参与执行。

Java解决方案：同步机制

Java对于多线程的安全问题提供了专业的解决方式：同步机制

方式一：同步代码块

synchronized (对象){
    // 需要被同步的代码；
}

说明：

  1. 操作共享数据的代码，即为需要被同步的代码。 –>不能包含代码多了，也不能包含代码少了。
  2. 共享数据：多个线程共同操作的变量。比如：ticket就是共享数据。
  3. 同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。要求：多个线程必须要共用同一把锁。

补充：

  1. 在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器（锁）。
  2. 在继承Thread类创建多线程的方式中，慎用this充当同步监视器，考虑使用当前类充当同步监视器。

方式二：同步方法

如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明同步的。

public synchronized void show (String name){
    ….
}

关于同步方法的总结

  1. 同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。
  2. 非静态的同步方法，同步监视器是：this
  3. 静态的同步方法，同步监视器是：当前类本身

方式三：Lock锁 — JDK5.0新增

synchronized 与 Lock的异同？

  • 相同：二者都可以解决线程安全问题

  • 不同：synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器

Lock需要手动的启动同步（lock()，同时结束同步也需要手动的实现（unlock()）

Lock —> 同步代码块（已经进入了方法体，分配了相应资源 ) —> 同步方法（在方法体之外)

利弊

同步的方式，解决了线程的安全问题。—好处

操作同步代码时，只能一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。

死锁

不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃 自己需要的同步资源，就形成了线程的死锁

出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于 阻塞状态，无法继续

public static void main(String[] args) {

    StringBuffer s1 = new StringBuffer();
    StringBuffer s2 = new StringBuffer();


    new Thread(){
        @Override
        public void run() {

            synchronized (s1){

                s1.append("a");
                s2.append("1");

                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }


                synchronized (s2){
                    s1.append("b");
                    s2.append("2");

                    System.out.println(s1);
                    System.out.println(s2);
                }


            }

        }
    }.start();


    new Thread(new Runnable() {
        @Override
        public void run() {
            synchronized (s2){

                s1.append("c");
                s2.append("3");

                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                synchronized (s1){
                    s1.append("d");
                    s2.append("4");

                    System.out.println(s1);
                    System.out.println(s2);
                }


            }



        }
    }).start();


}

加个sleep，让死锁的概率高一点

  • 第一个线程等待拿s2，第二个线程等待拿s1

线程通信

线程通信涉及到的三个方法

  • wait():一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。
  • notify():一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级高的那个。
  • notifyAll():一旦执行此方法，就会唤醒所有被wait的线程。

说明

  • wait()，notify()，notifyAll()三个方法必须使用在同步代码块或同步方法中。
  • wait()，notify()，notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器。否则，会出现IllegalMonitorStateException异常
  • wait()，notify()，notifyAll()三个方法是定义在java.lang.Object类中。

面试题

sleep() 和 wait()的异同？

  • 相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态。
  • 不同点：
  • 两个方法声明的位置不同：Thread类中声明sleep() , Object类中声明wait()
  • 调用的要求不同：sleep()可以在任何需要的场景下调用。 wait()必须使用在同步代码块或同步方法中
  • 关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁，wait()会释放锁。

小结释放锁的操作

image-20201101221959183.png

小结不会释放锁的操作

image-20201101222024317.png

2 评论

用户头像
陈平安   2021-11-22 00:03         踩      回复

并发那里是不是应该改成一个人做多件事。

用户头像
迷弟   2020-11-02 12:21         踩      回复

感觉多线程好厉害、要是能自动就好了(