• 【Java学习Note】第8章 多线程

    8. 多线程

    文章目录

    8.1 程序、进程、线程

    • 程序(program)：为完成特定任务，用某种语言编写的一组指令集合。即指一段静态的代码，静态对象。

    • 进程(process)：是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。——生命周期

      如：运行中的QQ，运行中的MP3播放器

      程序是静态的，进程是动态的

      进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域

    • 线程(thread)：进程可进一步细化为线程，是一个程序内部的一条执行路径。

      若一个进程同一时间并行执行多个线程**，**就是支持多线程的

      线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)，线程切换的开销小

      一个进程中的多个线程共享相同的内存单元/内存地址空间（就是公用堆和虚拟机栈），它们从同一堆中分配对象，可以访问相同的变量和对象。这就使得线程间通信更简便、高效（因为栈是共享）。但多个线程操作共享的系统资源可能就会带来安全的隐患。

      单线程和多线程：

      image-20221026200242430

    • 单核CPU和多核CPU

      单核CPU，其实是一种假的多线程，因为在一个时间单元内，也只能执行一个线程的任务，它只是在不同的线程任务中来回切换，来实现多线程。

      例如：虽然有多车道，但是收费站只有一个工作人员在收费，只有收了费才能通过，那么CPU就好比收费人员。如果有某个人不想交钱，那么收费人员可以把他“挂起”（晾着他，等他想通了，准备好了钱，再去收费）。

      但是因为CPU时间单元特别短，因此感觉不出来，感觉就是多线程。

      如果是多核的话，才能更好的发挥多线程的效率。（现在的服务器都是多核的）

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

    • 并行和并发

      并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事。

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

    那么为什么使用多线程？

    以单核CPU为例，只使用单个线程先后完成多个任务（调用多个方法），肯定比用多个线程来完成用的时间更短（因为单核CPU想要实现多线程需要在不同线程来回切换，期间耗费时间，但单核CPU的多线程是虚假的多线程）

    只有多核CPU才能体现多线程的优势

    多线程程序的优点：

    1. 提高应用程序的响应。对图形化界面更有意义，可增强用户体验。

    2. 提高计算机系统CPU的利用率

    3. 改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改

    8.2 线程的创建

    • 每个线程都是通过某个特定Thread对象的run()方法来完成操作的，经常把run()方法的主体称为线程体
    • 通过该Thread对象的start()方法来启动这个线程，而非直接调用run()

    Thread类

    1. Thread()**：**创建新的Thread对象
    2. Thread(String threadname)**：**创建线程并指定线程实例名
    3. Thread(Runnable target)：指定创建线程的目标对象，它实现了Runnable接口中的run方法
    4. Thread**(**Runnable target, String name)：创建新的Thread对象

    API中创建线程的两种方式

    8.2.1 继承Thread类-创建线程方法之一

    步骤：

    1. 定义Thread类的子类
    2. 重写Thread类中的run方法
    3. 创建Thread子类对象即创建线程对象
    4. 调用线程对象start()方法。start()方法的作用：启动线程，并由JVM调用线程的run方法。

    这里给创建匿名Thread子类对象：

    new Thread(){
    @Override
    public void run() {
        for(int i = 0;i<100;i++)
        {
            System.out.println(getName()+":"+i);
        }
    }
}.start();

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    image-20221028094917318

    每个线程都有自己的名字，可以使用Thread.currentThread().getName()来查看当前线程名，内部提供私有静态整型变量（数字）给每个线程起名，我么也可以通过方法setName()修改线程的名字

    image-20221028104323722

    • 多线程的执行过程–不同线程同时进行

      image-20221028095627843

    • 多线程注意事项

      1. 手动调用run()方法，只是调用类中普通方法，没有启动多线程模式（启动多线程必须调用start方法）。

      2. run()方法由JVM调用，调用时机，执行的过程控制都有操作系统的CPU调度决定。

      3. 一个线程对象只能调用一次start()方法启动，如果重复调用了，则将抛出以上的异常“IllegalThreadStateException”。创建多个线程就创建多个对象。

        image-20221028095948820

      4. 当线程只是用一次，我们可以考虑使用匿名子类对象创建多线程

    8.2.2 Thread常用方法

    • start():启动当前线程；调用当前线程的run()
    • run(): 通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
    • currentThread():静态方法，返回执行当前代码的线程引用
    • getName():获取当前线程的名字
    • setName():设置当前线程的名字
    • yield():释放当前cpu的执行权，也有可能刚才的线程又回来了。（静态的，可直接调用）不释放同步锁
    • join():在线程a中调用线程b的join()，此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态。（该函数抛异常，非静态）
    • stop():已过时。当执行此方法时，强制结束当前线程。
    • sleep(long millitime):让当前线程“睡眠”指定的millitime毫秒。在指定的millitime毫秒时间内，当前线程处于阻塞，并且不释放同步锁（该函数抛异常，静态）
    • isAlive():判断当前线程是否存活

    反对使用stop()，是因为它不安全。它会解除由线程获取的所有锁定，而且如果对象处于一种不连贯状态，那么其他线程能在那种状态下检查和修改它们。结果很难检查出真正的问题所在。

    suspend()方法容易发生死锁。调用suspend()的时候，目标线程会停下来，但却仍然持有在这之前获得的锁定。此时，其他任何线程都不能访问锁定的资源，除非被"挂起"的线程恢复运行。对任何线程来说，如果它们想恢复目标线程，同时又试图使用任何一个锁定的资源，就会造成死锁。所以不应该使用suspend()，而应在自己的Thread类中置入一个标志，指出线程应该活动还是挂起。若标志指出线程应该挂起，便用wait()命其进入等待状态。若标志指出线程应当恢复，则用一个notify()重新启动线程。

    8.2.3 实现Runnable接口-创建线程方法之二

    步骤：

    1. 创建实现Runnable接口的实现类

    2. 类中重写Runnable接口中的run方法。（下面时接口Runnable）

      image-20221031145409023

    3. 创建实现类的对象

    4. 将实现类对象作为参数传递给Thread类的构造器，创建Thread类的对象（线程对象）

    5. 调用Thread类的start方法：开启线程，调用Runnable子类接口的run方法。

    举例：

    public class MyThread1 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i <100 ; i++) {
            System.out.println(Thread.currentThread().getName());
            if(i%2==0) System.out.println(i);
        }
    }

    public static void main(String[] args) {
        MyThread1 mThread = new MyThread1();
        Thread t1 = new Thread(mThread);
        t1.start();
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    那么具体是如何实现的呢？

    用对象实例构造Thread时，调用的时Thread(Runnable target)构造器，用一个接口接收对象，并且给Thread线程对象中修改target值。

    public Thread(Runnable target) {
        init(null, target, "Thread-" + nextThreadNum(), 0);
    }

    • 1
    • 2
    • 3

    在调用start时，内部调用start0()，start0()方法为native，内部JVM调用了run方法，被封装了。调用run方法，而target的run方法在创建线程的时候重写过了，所以从外表看像是调用了实现类中的run方法：

    @Override
public void run() {
    if (target != null) {
        target.run();
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    所以start方法作用：

    1. 启用线程
    2. 调用当前线程的run()----调用Runnable类型的target的run()方法

    这里给出以实现Runnable接口方式创建Thread线程匿名对象：

    new Thread(new Runnable(){
	public void run() {
		for (int i = 0; i < 100; i++) {
			System.out.println(Thread.currentThread().getName() + ":" + i);
		}
	}
}).start();

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    8.2.4 两种多线程的区别

    实现Runnable接口方式的好处

    • 避免了单继承的局限性（如果一个类本身有自己的父类，就无法通过继承Thread类来实现多线程）
    • 多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处理同一份资源。

    区别

    • 继承Thread：线程代码存放Thread子类run方法中。

    • 实现Runnable：线程代码存在接口的子类的run方法。

    本质上Thread内部有run方法，在run方法内部调用Runnable类型target的run方法。（有点绕）

    第一种继承thread类创建多线程的方式。子类重写了Thread类的run方法，但非接口中的run方法。调用的时候直接调用Thread重写后的方法。

    第二种实现Runnable接口的实现类，是实现了Thread类中Runnable类型target中的抽象方法run()。调用的时候，先调用Thread中的run方法，内部再调用接口中的方法，也就是target.run()；

    源码:

    image-20221031152124530

    补充：线程的分类 Java中的线程分为两类：一种是守护线程，一种是用户线程。

    • 它们在几乎每个方面都是相同的，唯一的区别是判断JVM何时离开。
    • 守护线程是用来服务用户线程的，通过在start()方法前调用 thread.setDaemon(true)可以把一个用户线程变成一个守护线程。
    • Java垃圾回收就是一个典型的守护线程。
    • 若JVM中都是守护线程，当前JVM将退出。

    8.3 线程得调度

    • 调度得策略
    1. 时间片：image-20221030233938311
    2. 抢占式：高优先级的线程抢占CPU
    • Java的调度方法

    同优先级线程组成先进先出队列（先到先服务）使用时间片策略

    对高优先级，使用优先调度的抢占式策略

    • 线程的优先级等级
    1. MAX_PRIORITY：10
    2. MIN_PRIORITY：1
    3. NORM_PRIORITY：5
    • 线程优先级方法

    getPriority() ：返回线程优先值

    setPriority(int newPriority) ：改变线程的优先级

    //1、5、10参数一般不写具体数值，而是写MAX_PRIORITY、MIN_PRIORITY、NORM_PRIORITY

    • 注意：

    线程创建时继承父线程的优先级

    低优先级只是获得调度的概率低，并非一定是在高优先级线程之后才被调用

    8.4 线程的生命周期

    JDK中用Thread.state类定义了线程的6种状态：具体看源码：

    public enum State {
        /**
         * Thread state for a thread which has not yet started.
         */
        NEW,

        /**
         * Thread state for a runnable thread.  A thread in the runnable
         * state is executing in the Java virtual machine but it may
         * be waiting for other resources from the operating system
         * such as processor.
         */
        RUNNABLE,

        /**
         * Thread state for a thread blocked waiting for a monitor lock.
         * A thread in the blocked state is waiting for a monitor lock
         * to enter a synchronized block/method or
         * reenter a synchronized block/method after calling
         * {@link Object#wait() Object.wait}.
         */
        BLOCKED,

        /**
         * Thread state for a waiting thread.
         * A thread is in the waiting state due to calling one of the
         * following methods:
         * 
      
         *   
    • {@link Object#wait() Object.wait} with no timeout
      • 
         *   
    • {@link #join() Thread.join} with no timeout
      • 
         *   
    • {@link LockSupport#park() LockSupport.park}
      • 
         * 
    
         *
         * 
    A thread in the waiting state is waiting for another thread to
         * perform a particular action.
         *
         * For example, a thread that has called Object.wait()
         * on an object is waiting for another thread to call
         * Object.notify() or Object.notifyAll() on
         * that object. A thread that has called Thread.join()
         * is waiting for a specified thread to terminate.
         */
        WAITING,

        /**
         * Thread state for a waiting thread with a specified waiting time.
         * A thread is in the timed waiting state due to calling one of
         * the following methods with a specified positive waiting time:
         * 
      
         *   
    • {@link #sleep Thread.sleep}
      • 
         *   
    • {@link Object#wait(long) Object.wait} with timeout
      • 
         *   
    • {@link #join(long) Thread.join} with timeout
      • 
         *   
    • {@link LockSupport#parkNanos LockSupport.parkNanos}
      • 
         *   
    • {@link LockSupport#parkUntil LockSupport.parkUntil}
      • 
         * 
    
         */    
        TIMED_WAITING,

        /**
         * Thread state for a terminated thread.
         * The thread has completed execution.
         */
        TERMINATED;
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64

    总结下来：

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

    8.5 线程的同步

    两个线程同时访问相同数据可能导致线程安全问题，Java提供同步锁机制解决线程安全问题。

    同步锁机制：

    对于并发工作，你需要某种方式来防止两个任务同时访问相同的资源（其实就是共享资源竞争）。 防止这种冲突的方法就是当资源被一个任务使用时，在其上加锁。第一个访问某项资源的任务必须锁定这项资源，使其他任务在其被解锁之前，就无法访问它了，而在其被解锁之时，另一个任务就可以锁定并使用它了。

    下面是三个窗口买票出现得线程安全问题：

    public class SynchronizedTest implements Runnable {
    private static int ticket = 1000;

    @Override
    public void run() {
        while (true) {
            if (ticket > 0) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println(Thread.currentThread().getName()+"窗口："+ticket--);
            }else break;
        }
    }

    public static void main(String[] args) {
        SynchronizedTest s = new SynchronizedTest();
        Thread t1 = new Thread(s);
        Thread t2 = new Thread(s);
        Thread t3 = new Thread(s);

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28

    我们查看卖票的部分情况：

    image-20221104150216532

    出现重票和非正常票数，这里就出现了线程安全问题。所以就要进行线程同步，使用关键字synchronized

    8.5.1 线程同步–Synchronized

    synchronized的锁是什么？

    • 任意对象都可以作为同步锁。所有对象都自动含有单一的锁（监视器）
    • 同步方法的锁：静态方法（类名.class）、非静态方法（this）
    • 同步代码块的锁：自己指定，很多时候也是指定为this或类名.class

    注意：

    • 必须确保使用同一个资源的多个线程共用一把锁，这个非常重要，否则就无法保证共享资源的安全
    • 一个线程类中的所有synchronized修饰的静态方法共用同一把锁（类名.class），所有非静态方法共用同一把锁（this），同步代码块（指定需谨慎）
    • 同步代码块
    synchronized(同步监视器){
	//需要被同步的代码
}
//1. 所谓需要同步的代码就是指操作共享数据的代码
//2. 同步监视器俗称锁，任何一个类的对象都能充当锁（要求多个线程公用一把锁。可以考虑将对象声明为static类型）
//3. 补充：在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器。

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • synchronized修饰方法为同步方法
    public synchronized void show(String name){
    //非静态synchronized方法同步监视器为this
    //静态synchronized方法同步监视器为类名.class（静态的准没错！）
}

    • 1
    • 2
    • 3
    • 4

    8.5.2 释放锁操作和不释放锁操作

    释放锁

    1. 当前线程的同步方法、同步代码块执行结束。
    2. 当前线程在同步代码块、同步方法中遇到break、return终止了该代码块、该方法的继续执行。
    3. 当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束。
    4. 当前线程在同步代码块、同步方法中执行了线程对象的**wait()**方法，当前线程暂停，并释放锁。

    不会释放锁

    1. 线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行
    2. 线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁（同步监视器）。
      • 应尽量避免使用suspend()和resume()来控制线程这连个方法已经被弃用

    8.5.3 两种多线程的两种线程同步

    1. 使用同步代码块解决继承Thread类的线程安全问题

      class Window2 extends Thread {
    
    private static int ticket = 1000;
    
    private static Object obj = new Object();

    @Override
    public void run() {

        while (true) {
            //正确的
            synchronized (Window2.class){//Class clazz = Window2.class,Window2.class只会加载一次
//            synchronized (obj) {
//            synchronized (this) {//错误的方式：this代表着t1,t2,t3三个对象

                if (ticket > 0) {

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

                    System.out.println(getName() + "：卖票，票号为：" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }

        }

    }
}

public class WindowTest2 {
    public static void main(String[] args) {
        Window2 t1 = new Window2();
        Window2 t2 = new Window2();
        Window2 t3 = new Window2();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();

    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38
      • 39
      • 40
      • 41
      • 42
      • 43
      • 44
      • 45
      • 46
      • 47
      • 48
      • 49
      • 50
      • 51

    2. 使用同步代码块解决实现Runnable接口的线程安全问题

      class Window1 implements Runnable {

    private int ticket = 1000;

    @Override
    public void run() {
        while (true) {
            synchronized (this) {//此时的this:唯一的Window1的对象
//            synchronized (Window1.class) {
                if (ticket > 0) {

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

                    System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);


                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}

public class WindowTest1 {
    public static void main(String[] args) {
        Window1 w = new Window1();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

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

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38
      • 39
      • 40
      • 41
      • 42
      • 43
      • 44
      • 45
      • 46

      同步代码块解决线程安全问题就是将操作共享数据的代码用同一个同步监视器+synchronized关键字包裹。这里注意多线程必须使用同一个同步监视器（锁）。具体是否使用同一个监视器还需还应该看多线程的实现方式。

      • 用实现Runnable接口的类来实现的多线程，我们是创建该类的一个对象，用该对象来创建多个Thread线程对象，调用不同线程的start方法来实现多线程。所以在使用的同步监视器（锁）可以是this、类内对象（静态、非静态）、类名.class。
      • 用子类继承thread方式实现多线程，是通过创建多个子类对象并调用start来实现多线程。所以使用的同步监视器（锁）可以是类名.class、类内静态对象。而对于this和类内非静态对象是不可以的！因为实现多线程的方式决定了器同步监视器不唯一。

    3. 使用同步方法解决继承Thread类的线程安全问题

      class Window4 extends Thread {

    private static int ticket = 1000;

    @Override
    public void run() {

        while (true) {

            show();
        }

    }
    private static synchronized void show(){//同步监视器：Window4.class
        //private synchronized void show(){ //同步监视器：t1,t2,t3。此种解决方式是错误的
        if (ticket > 0) {

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

            System.out.println(Thread.currentThread().getName() + "：卖票，票号为：" + ticket);
            ticket--;
        }
    }
}


public class WindowTest4 {
    public static void main(String[] args) {
        Window4 t1 = new Window4();
        Window4 t2 = new Window4();
        Window4 t3 = new Window4();


        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();

    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38
      • 39
      • 40
      • 41
      • 42
      • 43
      • 44
      • 45
      • 46
      • 47

    4. 使用同步方法解决实现Runnable接口的线程安全问题

      class Window3 implements Runnable {

    private int ticket = 100;

    @Override
    public void run() {
        while (true) {

            show();
        }
    }

    private synchronized void show(){//同步监视器：this
        //synchronized (this){

            if (ticket > 0) {

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

                System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);

                ticket--;
            }
        //}
    }
}


public class WindowTest3 {
    public static void main(String[] args) {
        Window3 w = new Window3();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

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

}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38
      • 39
      • 40
      • 41
      • 42
      • 43
      • 44
      • 45
      • 46
      • 47
      • 48
      • 49
      • 50

      使用synchronized修饰方法，对于静态的方法的同步锁就是类名.class，对于非静态的方法的同步锁就是this。所以子类继承Thread类的方法一般不能使用synchronized修饰非静态的方法来达到线程同步。因为子类继承Thread方式实现多线程需要创建多个线程，对应不同的this，导致同步监视器不唯一。（本质上来说就是确保同步监视器唯一！）

    8.5.4 懒汉式线程安全问题

    public class Bank {
    private Bank() {
    };

    private static Bank instance = null;

    public static Bank getInstance() {

//        //线程不安全
//        if(instance==null){
//            instance = new Bank();
//        }
//        return instance;

//        //线程安全，但是效率差
//        synchronized (Bank.class) {
//            if (instance == null) {
//                instance = new Bank();
//            }
//            return instance;
//        }
        
        //线程安全且效率高
        if (instance == null) {

            synchronized (Bank.class) {
                if (instance == null) {
                    instance = new Bank();
                }
            }
        }
        return instance;
    
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35

    8.6 死锁

    不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己的同步资源，就形成了线程的死锁。出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续。

    死锁在开发中难以看出，为避免死锁，可以尽量减少同步资源的定义或尽量避免嵌套同步。下面是一个死锁例子：

    class A {
	public synchronized void foo(B b) {
		System.out.println("当前线程名: " + Thread.currentThread().getName()
				+ " 进入了A实例的foo方法"); 
		try {
			Thread.sleep(200);
		} catch (InterruptedException ex) {
			ex.printStackTrace();
		}
		System.out.println("当前线程名: " + Thread.currentThread().getName()
				+ " 企图调用B实例的last方法"); 
		b.last();
	}

	public synchronized void last() {
		System.out.println("进入了A类的last方法内部");
	}
}

class B {
	public synchronized void bar(A a) {
		System.out.println("当前线程名: " + Thread.currentThread().getName()
				+ " 进入了B实例的bar方法");
		try {
			Thread.sleep(200);
		} catch (InterruptedException ex) {
			ex.printStackTrace();
		}
		System.out.println("当前线程名: " + Thread.currentThread().getName()
				+ " 企图调用A实例的last方法"); 
		a.last();
	}

	public synchronized void last() {
		System.out.println("进入了B类的last方法内部");
	}
}

public class DeadLock implements Runnable {
	A a = new A();
	B b = new B();

	public void init() {
		Thread.currentThread().setName("主线程");
		// 调用a对象的foo方法
		a.foo(b);
		System.out.println("进入了主线程之后");
	}

	public void run() {
		Thread.currentThread().setName("副线程");
		// 调用b对象的bar方法
		b.bar(a);
		System.out.println("进入了副线程之后");
	}

	public static void main(String[] args) {
		DeadLock dl = new DeadLock();
		new Thread(dl).start();
		dl.init();
	}
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63

    案例中每一个线程执行完都需要手握两把锁，但上面的例子是两个线程分别手握一把锁，都在等待对方释放锁，所以形成死锁。（主线程手握a锁，需要b锁，副线程手握b锁，需要a锁）

    8.7 线程同步之三-Lock

    从JDK 5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。

    java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象

    ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。

    class AA implements Runnable{
//class AA extends Thread{//继承的方式确保锁唯一，需用static
//private final static ReentrantLock lock = new ReentrantLock();
    private final ReentrantLock lock = new ReentrantLock();
    
    public void run(){
        lock.lock();
        try{
            //保证线程安全的代码;
        }
        finally{
            lock.unlock();
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    如上代码，在使用实现Runnable接口时，Lock可以定义成非静态的，因为实现Runnable接口方式实现的多线程，一般只创建一个实现类对象，将该实现类对象作为参数创建多个线程，所以这写线程都是公用的实现类中同一个的Lock同步锁。当然如果你硬是创建了两个实现类，分别创建不同对象，那这个线程同步就不好使了。

    如果时继承Thread类的方式实现多线程，就必须将Lock定义成静态了，因为继承Thread类方式实现的多线程会构建多个子类对象，这个时候存在多个Lock同步锁，这时线程就不是安全的了

    8.7.1 synchronized 与 Lock 的对比

    1. Lock是显式锁（手动开启和关闭锁，别忘记关闭锁），synchronized是隐式锁，出了作用域自动释放

    2. Lock只有代码块锁，synchronized有代码块锁和方法锁

    3. 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）

    优先使用顺序：

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

    8.8 线程通信

    所谓线程通信就是不同线程之间信息交流，具体通过调用Object类种定义的方法实现，如下：

    wait()：令当前线程挂起并放弃CPU、同步资源并等待，使别的线程可访问并修改共享资源，而当前线程排队等候其他线程调用notify()或notifyAll()方法唤醒，唤醒后等待重新获得对监视器的所有权后才能继续执行。

    notify()：唤醒等待同步资源的线程中任意一个线程！（arbitrary！）

    image-20221120182151322

    notifyAll ()：唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。

    wait()、notify()、notifyAll()只有在synchronized方法或synchronized代码块中才能使用，否则会报java.lang.IllegalMonitorStateException异常。

    wait()、notify()、notifyAll()调用者必须是同步代码块或同步方法中的同步监视器，否则会报java.lang.IllegalMonitorStateException异常

    wait()、notify()、notifyAll()是定义在java.lang.Object类中的，因为任何一个对象都能充当同步监视器，所以就需要任何一个对象都能调用这三个方法。

    因为这三个方法必须由同步监视器来调用，而任意对象都可以作为synchronized的同步锁，因此这三个方法只能在Object类中声明。

    8.8.1 IllegalMonitorStateException

    对然编译通过？但运行任然报错？本文以生产者消费者问题讲解本人遇到的 IllegalMonitorStateException问题！

    image-20221108152840966

    首先明确wait()、notify()、notifyAll()调用者必须是同步代码块或同步方法中的同步监视器，否则会报java.lang.IllegalMonitorStateException异常。下面带大家细品这句话。

    解决的办法很简单，找到同步监视器，在wait()、notify()、notifyAll()前显示的加上调用者（同步监视器）。

    有了解决方法下面带大家看看为什么会出错？

    先看结论：省略wait()、notify()、notifyAll()的调用者，在同步代码块中会报错，在同步非静态方法中不会报错。为什么呢？

    下面是本人用实现Runnable接口的方式解决生产者消费者问题的线程安全问题，大家只需要关注Clerk类中consuming方法和producing方法中wait的调用者是谁？

    public class PCThreadSecuity {
    public static void main(String[] args) {
        Produce produce = new Produce();
        Thread t1 = new Thread(produce);
        t1.setName("生产者");

        Customer customer = new Customer();
        Thread t2 = new Thread(customer);
        t2.setName("消费者");

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

    }
}

class Clerk {

    static int commodityNumber = 0;

    public void producing() {
        synchronized (Clerk.class) {
            if (Clerk.commodityNumber < 20) {

                Clerk.commodityNumber++;

                try {
                    Thread.sleep(20);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }

                System.out.println(Thread.currentThread().getName() + ":第" + Clerk.commodityNumber + "个产品加急ing.......");
//                Clerk.class.notify();//正确写法
                notify();//错误写法
            } else {
                try {
//                    Clerk.class.wait();//正确写法
                    wait();//错误写法
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }

    public void consuming() {
        synchronized (Clerk.class) {
            if (Clerk.commodityNumber > 0) {

                System.out.println(Thread.currentThread().getName() + ":第" + Clerk.commodityNumber + "个产品已被消费.......");

                try {
                    Thread.sleep(20);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }

                Clerk.commodityNumber--;
//                Clerk.class.notify();//正确写法
                notify();//错误写法
            } else {
                try {
                    //Clerk.class.wait();//正确写法
                    wait();//错误写法
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }

        }
    }
}

class Produce implements Runnable {


    Clerk c = new Clerk();

    @Override
    public void run() {
        while (true) {
            c.producing();
        }
    }
}

class Customer implements Runnable {


    Clerk c = new Clerk();

    @Override
    public void run() {
        while (true) {
            c.consuming();
        }
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100

    看看此处的wait的调用者？

    image-20221108155409482

    省略了就是this，this指代当前调用对象，是同步监视器吗？不是！为什么编译能过？首先任何一个对象都能充当同步监视器，所以wait()、notify()、notifyAll()都是定义在Object类中的，所以任何对象都能调用这三个方法。所以编译过了，但运行不是同步监视器，所以报错了呗。解决方法就是显示写出同步监视器！

    8.8.2 面试题- sleep() 和 wait()

    面试题：sleep() 和 wait()的异同？

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

    面试题：

    8.9 实现Callable接口-创建线程方法之三

    1. 创建一个实现Callable的实现类

    2. 实现call方法，将此线程需要执行的操作声明在call()中

    3. 创建Callable接口实现类的对象

    4. 将此Callable接口实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask的对象（此处调用的构造函数接收的是接口Callable）

      image-20221108165738987

    5. 将创建好的FutureTask类对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()

      获取Callable中call方法的返回值可以调用FutureTask对象中的get方法。get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。

    代码案例：

    package com.atguigu.exer;

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

//1.创建一个实现Callable的实现类
class NumThread implements Callable{
    //2.实现call方法，将此线程需要执行的操作声明在call()中
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            if(i % 2 == 0){
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}


public class ThreadNew {
    public static void main(String[] args) {
        //3.创建Callable接口实现类的对象
        NumThread numThread = new NumThread();
        //4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask futureTask = new FutureTask(numThread);
        //5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
        new Thread(futureTask).start();

        try {
            //6.获取Callable中call方法的返回值
            //get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
            Object sum = futureTask.get();
            System.out.println("总和为：" + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46

    8.9.1 Future接口

    1. 可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等。
    2. FutrueTask是Futrue接口的唯一的实现类
    3. FutureTask 同时实现了Runnable, Future接口。它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值
    image-20221108170149180

    8.10 线程池-创建线程方式之四

    经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用.

    利用线程池创建多线程有很多好处：

    1. 提高相应速度（减少了创建新线程的时间）

    2. 降低资源消耗（重复利用线程池中线程，不需要每次都创建）

    3. 便于资源管理（ThreadPoolExecutor中提供如下属性：）

      • corePoolSize：核心池的大小

      • maximumPoolSize：最大线程数

      • keepAliveTime：线程没有任务时最多保持多长时间后会终止

    JDK 5.0起提供了线程池相关API：ExecutorService 和 Executors

    • ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor

      void execute(Runnable command) ：执行任务/命令，没有返回值，一般用来执行Runnable

      Future submit(Callable task)：执行任务，有返回值，一般又来执行Callable

      void shutdown() ：关闭连接池

    • Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池

      Executors.newCachedThreadPool()：创建一个可根据需要创建新线程的线程池

      Executors.newFixedThreadPool(n); 创建一个可重用固定线程数的线程池

      Executors.newSingleThreadExecutor() ：创建一个只有一个线程的线程池

      Executors.newScheduledThreadPool(n)：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。

    实例：

    package com.atguigu.exer;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;

/**
 * 创建线程的方式四：使用线程池
 *
 * 好处：
 * 1.提高响应速度（减少了创建新线程的时间）
 * 2.降低资源消耗（重复利用线程池中线程，不需要每次都创建）
 * 3.便于线程管理
 *      corePoolSize：核心池的大小
 *      maximumPoolSize：最大线程数
 *      keepAliveTime：线程没有任务时最多保持多长时间后会终止
 *
 * 面试题：创建多线程有几种方式？四种！
 */

class NumberThread implements Runnable{

    @Override
    public void run() {
        for(int i = 0;i <= 100;i++){
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        }
    }
}

class NumberThread1 implements Runnable{

    @Override
    public void run() {
        for(int i = 0;i <= 100;i++){
            if(i % 2 != 0){
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        }
    }
}

public class ThreadPool {

    public static void main(String[] args) {
        //1. 提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
//        System.out.println(service instanceof ThreadPoolExecutor);//true
        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;//为什么能这么强制类型转换？哈哈哈哈看源码就懂啦
        
        //设置线程池的属性
//        System.out.println(service.getClass());
//        service1.setCorePoolSize(15);
//        service1.setKeepAliveTime();


        //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumberThread());//适合适用于Runnable
        service.execute(new NumberThread1());//适合适用于Runnable

//        service.submit(Callable callable);//适合使用于Callable
        //3.关闭连接池
        service.shutdown();
    }

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68

    这段代码中引起我关注的是：

     ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;//为什么能这么强制类型转换？哈哈哈哈看源码就懂啦

    • 1

    service是ExecutorService类型，作为接口。而ThreadPoolExecutor是他的实现类。还能这么转？看了原码才知道，函数newFixedThreadPool虽然返回值类型是接口ExecutorService，但方法内部实际上造的是ThreadPoolExecutor类型！所以才能这么转嘛hhhhhh

    线程池继承树：

    image-20221108190019425

    注意啦Executor是接口，Executor是工具类！00

  • 相关阅读:
    漏洞复现-蓝凌LandrayOA系列
    [游戏设计心法]4-如何让玩家投入
    （二）《数字电子技术基础》——数制
    Redis从入门到精通
    QT中表格控件使用
    四川竹哲电子商务有限公司创造抖音电商新高度
    哪款蓝牙耳机平价好用？值得学生党入手的蓝牙耳机推荐
    【多线程笔记02】多线程之CyclicBarrier的介绍和使用
    PAT甲级 1072 Gas Station(30) (Dijkstrla)
    tsdx 打包ts项目
  • 原文地址：https://blog.csdn.net/weixin_63267854/article/details/128199843