17.多线程基础|Java学习笔记

已于 2023-06-13 23:28:11 修改
阅读量678 收藏
点赞数 1
分类专栏： Java 文章标签： java 多线程 锁 synchronized
于 2021-11-20 00:00:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43406895/article/details/121191248
版权

文章目录

线程相关概念

程序

是为完成特定任务、用某种语言编写的一组指令的集合。简单的说:就是我们写的代码

进程

  1. 进程是指运行中的程序，比如我们使用QQ，就启动了一个进程，操作系统就会为该进程分配内存空间。当我们使用迅雷，又启动了一个进程，操作系统将为迅雷分配新的内存空间。
  2. 进程是程序的一次执行过程，或是正在运行的一个程序。是动态过程:有它自身的产生、存在和消亡的过程。

线程

  1. 线程由进程创建的，是进程的一个实体。
  2. 一个进程可以拥有多个线程。

其他相关概念

  1. 单线程：同一个时刻，只允许执行一个线程。
  2. 多线程：同一个时刻，可以执行多个线程。【比如：一个qq进程，可以同时打开多个聊天窗口；一个迅雷进程，可以同时下载多个文件】
  3. 并发：同一个时刻，多个任务交替执行，造成一种“貌似同时”的错觉，简单地说，单核cpu实现的多任务就是并发。
  4. 并行：同一个时刻，多个任务同时执行。多核cpu可以实现并行。

线程的基本使用

创建线程的两种方式

在这里插入图片描述

继承Thread类

注意重写的是 run() 方法，但调用时使用的是 start() 方法。

package com.fwedu.threaduse;

public class Thread01 {
    public static void main(String[] args) throws InterruptedException {
        Cat cat = new Cat();
        cat.start();

        // 当main线程启动一个子线程时，不会阻塞
        // 交替进行
        System.out.println("主线程进行执行:" + Thread.currentThread());
        for (int i = 0; i < 10; i++) {
            System.out.println("主线程 i = " + i);
            // 让主线程休眠
            Thread.sleep(1000);
        }
    }
}

class Cat extends Thread {
    int times = 1;

    @Override
    public void run() {
        do {
            System.out.println("喵喵，我是魔法猫咪" + (times++) + " 线程名称" + Thread.currentThread());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } while (times != 80);
    }
}

输出结果大致如下：
主线程进行执行:Thread[main,5,main]
主线程 i = 0
喵喵，我是魔法猫咪1 线程名称Thread[Thread-0,5,main]
主线程 i = 1
喵喵，我是魔法猫咪2 线程名称Thread[Thread-0,5,main]
主线程 i = 2
喵喵，我是魔法猫咪3 线程名称Thread[Thread-0,5,main]
主线程 i = 3
......

调用
Q: 为什么使用 start() 而不是 run() ?
A: 直接调用run()方法，意味着会把run方法当做一个main方法进行执行，并不会在某个线程中执行它，而是在主线程中进行执行。
在这里插入图片描述

实现Runnable接口

说明

  1. java是单继承的，在某些情况下一个类可能已经继承了某个父类,这时在用继承Thread类方法来创建线程显然不可能了。
  2. java设计者们提供了另外一个方式创建线程，就是通过实现Runnable接口来创建线程。
package com.fwedu.threaduse;

public class Thread02 {
    public static void main(String[] args) {
         Dog dog = new Dog();
         // dog.start();   // 并没有start方法

         // 一种代理
//         Thread thread = new Thread(dog);
//         thread.start();

        Tiger tiger = new Tiger();
//        ThreadProxy threadProxy = new ThreadProxy(tiger);   // 使用自己实现的代理
        ThreadProxy threadProxy = new ThreadProxy(dog);   // 使用自己实现的代理
        threadProxy.start();
    }
}

class Animal {

}

class Tiger extends Animal implements Runnable{

    @Override
    public void run() {
        System.out.println("老虎嗷嗷叫。。。");
    }
}

/**
 * 线程代理
 **/
class ThreadProxy implements Runnable {
    private Runnable target = null;

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

    public ThreadProxy(Runnable target) {
        this.target = target;
    }

    public void start() {
        start0();
    }

    public void start0() {
        run();
    }
}

class Dog implements Runnable {
    int count = 0;

    @Override
    public void run() {
        while (true) {
            System.out.println("小狗汪汪叫..hi" + (++count) + Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            if (count == 10) {
                break;
            }
        }
    }
}

例子中

Dog dog = new Dog();
// Dog类实现了接口Runnable接口，重写了run()方法，但是它并没有start()方法
// 因此需要
Thread thread = new Thread(dog);	// 作为一个代理
thread.start();

继承Thread vs 实现Runnable的区别

  1. 继承了Thread
Cat cat = new Cat();
cat.start();
  1. 实现Runnable
Dog dog = new Dog();
Thread thread = new Thread(dog);
thread.start();
  1. 从 java 的设计来看，通过继承 Thread 或者实现 Runnable 接口来创建线程本质上没有区别，从jdk帮助文档我们可以看到 Thread 类本身就实现了 Runnable 接口。
  2. 实现 Runnable 接口方式更加适合多个线程共享一个资源的情况，并且避免了单继承的限制，建议使用Runnable。

线程终止

  1. 当线程完成任务后，会自动退出。
  2. 还可以通过使用变量来控制run方法退出的方式停止线程，即通知方式。

下面例子中，在主线程中通过设置对象 t 中的属性 loop=false，使线程 t 停止下来。

package com.fwedu.exit_;

public class ThreadExit01 {
    public static void main(String[] args) {
        T t = new T();
        t.start();

        try {
            Thread.sleep(10 * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t.setLoop(false);
    }
}


class T extends Thread {
    private int count = 0;
    private boolean loop = true;

    public void setCount(int count) {
        this.count = count;
    }

    public void setLoop(boolean loop) {
        this.loop = loop;
    }

    @Override
    public void run() {
        while (loop) {
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("T 运行中 " + (++count));
        }
    }
}

线程常用方法

1. setName() 		设置线程名称，使之与参数name相同
2. getName() 		返回该线程的名称
3. start()			使该线程开始执行;Java虚拟机底层调用该线程的start0方法
4. run()			调用线程对象 run方法;
5. setPriority() 	更改线程的优先级
6. getPriority() 	获取线程的优先级
7. sleep()     		在指定的毫秒数内让当前正在执行的线程休眠（暂停执行)
8. interrupt() 		中断线程
9. yield()			线程的礼让。让出cpu，让其他线程执行，但礼让的时间不确定，所以也不一定礼让成功
10. join()			线程的插队。插队的线程一旦插队成功，则肯定先执行完插入的线程所有的任务

注意事项和细节

  1. start底层会创建新的线程，调用run, run 就是一个简单的方法调用,不会启动新线程
  2. 线程优先级的范围
/**
* The minimum priority that a thread can have.
*/
public final static int MIN_PRIORITY = 1;

/**
* The default priority that is assigned to a thread.
*/
public final static int NORM_PRIORITY = 5;

/**
* The maximum priority that a thread can have.
*/
public final static int MAX_PRIORITY = 10;
  1. interrupt：中断线程，但并没有真正的结束线程。所以一般用于中断正在休眠线程。
  2. sleep：线程的静态方法，使当前线程休眠

用户线程和守护线程

  1. 用户线程User Thread:也叫工作线程，当线程的任务执行完或通知方式结束
  2. 守护线程Daemon Thread:一般是为工作线程服务的，当所有的用户线程结束，守护线程自动结束（常见的守护线程:垃圾回收机制）

  只要当前JVM实例中尚存在任何一个非守护线程没有结束，守护线程就全部工作；只有当最后一个非守护线程结束时，守护线程随着JVM一同结束工作。
  Daemon的作用是为其他线程的运行提供便利服务，守护线程最典型的应用就是 GC (垃圾回收器)，它就是一个很称职的守护者。
User和Daemon两者几乎没有区别，唯一的不同之处就在于虚拟机的离开：如果 User Thread已经全部退出运行了，只剩下Daemon Thread存在了，虚拟机也就退出了。 因为没有了被守护者，Daemon也就没有工作可做了，也就没有继续运行程序的必要了。

MyDaemonThread myDaemonThread = new MyDaemonThread();
myDaemonThread.setDaemon(true);
myDaemonThread.start();

线程的生命周期

    public enum State {

        /**
         * 尚未启动的线程处于此状态。 
         */
        NEW,

        /**
         * 在Java虚拟机中执行的线程处于此状态。 
         */
        RUNNABLE,

        /**
         * 被阻塞等待监视器锁定的线程处于此状态。 
         */
        BLOCKED,

        /**
         * 正在等待另一个线程执行特定动作的线程处于此状态。 
         */
        WAITING,

        /**
         * 正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。 
         */
        TIMED_WAITING,

        /**
         * 已退出的线程处于此状态。 
         */
        TERMINATED;
    }

  源码中可以看到一共有 6 种。
  其中 RUNNABLE 又可以分为 就绪 和 运行 2种状态。

线程状态转换图：
在这里插入图片描述

线程的同步

  1. 在多线程编程，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问技术，保证数据在任何同一时刻，最多有一个线程访问，以保证数据的完整性。
  2. 也可以这里理解:线程同步，即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作,其他线程才能对该内存地址进行操作.

Synchronized

Synchronized是非公平锁。 java中的锁——公平锁 / 非公平锁
在这里插入图片描述

使用 synchronized 可以解决多线程售票问题！（重要！）
（三种代码方式）
同步代码块：（锁this，锁任意一个对象的属性）（this锁是非公平锁，它是由JVM控制的，不保证等待时间最长的线程先获取锁，而是随机分配。非公平锁的优点是吞吐量高，缺点是可能造成线程饥饿。）
同步方法：

package com.fwedu.syn;

public class SellTicket {
    public static void main(String[] args) {
        SellTicket03 sellTicket03 = new SellTicket03();
        new Thread(sellTicket03).start();
        new Thread(sellTicket03).start();
        new Thread(sellTicket03).start();
    }
}

class SellTicket03 implements Runnable {
    private int ticketNum = 100;
    private boolean loop = true;

    final Object object = new Object();

//    public synchronized void  m() {       // 方法一
    public void  m() {
//        synchronized (this) {       // 方法二
        synchronized (object) {       // 方法三
            if (ticketNum <= 0) {
                loop = false;
                System.out.println("售票结束。。。");
                return;
            }

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

            System.out.println("窗口 " + Thread.currentThread().getName() + " 剩余票数" + (--ticketNum));
        }
    }

    @Override
    public void run() {
        while (loop) {
            m();
        }
    }
}

分析同步原理

在这里插入图片描述

互斥锁

基本介绍

  1. Java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性。
  2. 每个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象。
  3. 关键字 synchronized 来与对象的互斥锁联系。当某个对象用 synchronized 修饰时,表明该对象在任一时刻只能由一个线程访问。
  4. 同步的局限性：导致程序的执行效率要降低。
  5. 同步方法(非静态的)的锁可以是this,也可以是其他成员(要求是同一个对象)。
synchronized (this) {
}
  1. 同步方法(静态的)的锁为当前类本身。

注意事项和细节

  1. 同步方法如果没有使用static修饰：默认锁对象为this
  2. 如果方法使用static修饰，默认锁对象：当前类.class
  3. 实现的落地步骤:
    -需要先分析上锁的代码
    -选择同步代码块或同步方法
    -要求多个线程的锁对象为同一个即可!

线程的死锁

  多个线程都占用了对方的锁资源，但不肯相让，导致了死锁,在编程是一定要避免死锁的发生。
e.g.
在这里插入图片描述

一个导致死锁的示例：

package com.fwedu.syn;

public class DeadLock {
    public static void main(String[] args) {
        //模拟死锁现象
        DeadLockDemo A = new DeadLockDemo(true);
        A.setName("A 线程");
        DeadLockDemo B = new DeadLockDemo(false);
        B.setName("B 线程");
        A.start();
        B.start();
    }
}

class DeadLockDemo extends Thread {
    static Object o1 = new Object();
    static Object o2 = new Object();
    boolean flag;

    public DeadLockDemo(boolean flag) {
        this.flag = flag;
    }

    @Override
    public void run() {
        if (flag) {
            synchronized (o1) {
                System.out.println(Thread.currentThread().getName() + " 进入 1");
                synchronized (o2) {
                    System.out.println(Thread.currentThread().getName() + " 进入 2");
                }
            }
        } else {
            synchronized (o2) {
                System.out.println(Thread.currentThread().getName() + " 进入 3");
                synchronized (o1) {
                    System.out.println(Thread.currentThread().getName() + " 进入 4");
                }
            }
        }
    }
}

输出如下：
B 线程 进入 3
A 线程 进入 1
（然后就卡死在这里了...

释放锁

释放锁的情况

  1. 当前线程的同步方法、同步代码块执行结束。
    案例:上厕所，完事出来
  2. 当前线程在同步代码块、同步方法中遇到break、return。
    案例:没有正常的完事，经理叫他修改bug，不得已出来
  3. 当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束。
    案例:没有正常的完事，发现忘带纸,不得已出来
  4. 当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁。
    案例:没有正常完事，觉得需要酝酿下，所以出来等会再进去

不释放锁的情况

  1. 线程执行同步代码块或同步方法时，程序调用。Thread.sleep()、Thread.yield()方法暂停当前线程的执行,不会释放锁。
    案例:上厕所，太困了，在坑位上眯了一会
  2. 线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起,该线程不会释放锁。
    提示;应尽量避免使用 suspend() 和 resume() 来控制线程，方法不再推荐使用。
Wei *
关注
专栏目录
Java很好的学习笔记 多线程基础部分，学习代码
06-21
Java很好的学习笔记 多线程基础部分
Java基础及高级学习笔记.zip
09-26
本资料包“Java基础及高级学习笔记.zip”涵盖了Java的基础知识、进阶概念以及与面试相关的知识点，旨在帮助学习者从入门到精通，提升专业技能。 首先，"java基础.docx"文件详细讲解了Java的基础内容。这部分通常...
并发——单核cpu串行与并发的选择
ZHI11235813的博客
05-14 1549
1.下面所有内容均在单核单cpu情况下讨论。 不考虑I/O，执行任务相同的情况下，并发要比串行多消耗上下文切换的时间，因此单线程比多线程要快。上面这种情形（没有I/O）或者I/O较少的情况，我们称之为计算密集型（CPU-bound）任务，这种任务适合单线程。 与计算密集型任务相对的，就是IO密集型（I/O bound）任务。由于存在I/O阻塞的问题，线程在执行过程中需要等待。比如我们要获取10...
五种主要多核并行编程方法分析与比较
weixin_34344677的博客
02-18 1114
　　随着多核时代的到来与流行，传统的单线程串行程序的编程模式必将改变，取而代之的将是并行编程。目前已经有五种主要并行编程模型，下面将对此五种模型进行概括性的分析与比较： 1. MPI 　　MPI(Message Passing Interface)消息传递接口是MPI论坛发布的一个库，而不是一门实现语言，支持C/C++/Fortran。是一种消息传递编程模型，为进程间通信服务。MPI提供了一种...
Java多线程实战-实现多线程文件下载，支持断点续传、日志记录等功能
qq_35716689的博客
03-10 25万+
本文将介绍如何通过Java来实现一个多线程下载器。作者：牵着猫散步的鼠鼠
Java 多线程学习笔记
2301_76962889的博客
07-13 1909
*进程：**是操作系统进行资源分配和调度的基本单位，是程序的一次执行过程。**例如：**当你打开一个应用程序，如浏览器、音乐播放器等，操作系统就会为其创建一个进程。**线程：**是进程的一个执行单元，是 CPU 调度和分派的基本单位，一个进程可以包含多个线程。**例如：**在浏览器进程中，可以有多个线程同时运行，例如一个线程负责页面渲染，另一个线程负责网络请求。提高 CPU 利用率，充分利用多核处理器**例如：**下载软件使用多线程可以同时下载多个文件片段，充分利用带宽，提高下载速度。
Java多线程实战-异步操作日志记录解决方案(AOP+注解+多线程)
热门推荐
qq_35716689的博客
03-16 25万+
异步日志记录是一种提升系统性能和可维护性的有效手段。牵着猫散步的鼠鼠。通过将日志记录操作异步化，不仅可以减少对业务处理流程的影响，还可以提高日志处理的灵活性和扩展性。然而，实现异步日志记录机制也伴随着一定的挑战，如日志的实时性、顺序性和丢失风险等问题。
Java 多线程学习笔记（狂神）
qq_36188127的博客
11-18 3483
第1章 1.1 什么是线程 栈空间操作起来最快但是栈很小，通常大量的对象都是放在堆空间，栈和堆的大小都可以通过 JVM 的启动参数来进行调整，栈空间用光了会引发 StackOverflowError，而堆和常量池空间不足则会引发 OutOfMemoryError。 String str = new String("hello"); 上面的语句中变量 str 放在栈上，用 new 创建出来的字符串对象放在堆上，而 “hello” 这个字面量是放在方法区的。 1.2 线程的创建与运行 1.2.1 继承 T
猿创征文 | Java多线程-初级学习笔记
一只皮卡狗的博客
09-01 1930
首先，Java程序中所有的代码都运行在一条执行路径当中，而一条执行路径其实就是一个线程。换言之，我们所有的代码都是运行在某个线程当中的。
Java多线程实战-从零手搓一个简易线程池(一)定义任务等待队列
qq_35716689的博客
03-25 24万+
开个新坑-手搓简易线程池。本系列文章将从零开始,一步步手工编码实现一个简单但功能完备的线程池。我们将逐步介绍线程池的各个核心组件,并分析它们的作用和实现思路。通过这个过程,我们可以更好地掌握多线程编程的技巧,并培养编码能力和系统性思维。
Java学习笔记-多线程
cyh0503的博客
07-08 2863
并发与并行 并发：指两个或多个事件在同一个时间段内发生 并行：指两个或多个事件在同一时刻发生（同时发生） 在操作系统中，安装了多个程序，并发指的是在一段时间内宏观上有多个程序同时运行，这在单CPU系统中，每一时刻只能有一道程序执行，即微观上这些程序是分时的交替运行，只不过是给人的感觉是同时运行，那是因为分时交替运行的时间是非常短的。 而在多个CPU系统中，则这些可以并发执行的程序便可以分配到多...
多线程基础学习笔记
旋风小陀螺
03-12 1533
多线程基础学习笔记
Java基础 学习笔记 Markdownr版
06-27
本学习笔记主要涵盖了Java的基础知识，包括面向对象、集合、IO流、多线程、反射与动态代理以及Java 8的新特性等方面，旨在帮助初学者或有经验的开发者巩固和提升Java编程技能。 1. 面向对象（OOP）：Java的核心是...
Java基础尚硅谷宋红康学习笔记
05-29
7. **多线程**：Java内置了对多线程的支持，通过Thread类或实现Runnable接口可以创建并运行多个线程，实现并发执行。 8. **接口与内部类**：接口定义了一组方法签名，提供了一种实现多继承的方式。内部类（包括成员...
多线程-狂神说Java学习笔记
07-19
本学习笔记将深入探讨Java多线程的相关知识，包括其原理、实现方式、同步机制以及常见问题。 ### 一、多线程的基本概念 多线程是指在一个程序中存在两个或更多的执行线程，这些线程共享同一内存空间，但各自拥有...
junit5使用suite功能
fanfangyu的博客
10-23 241
2.调用类需要的代码。
Java中的序列化和反序列化？
程序猿老白~的博客
10-23 464
Java中的序列化和反序列化？
java_方法递归调用
最新发布
HHppGo的博客
10-27 259
简单的说: 递归就是方法自己调用自己,每次调用时传入不同的变量.递归有助于编程者解决复杂问题,同时可以让代码变得简洁。
Spring框架注解开发
2401_85217463的博客
10-23 909
名称：@Component @Controller @Service @Repository类型：类注解位置：类定义上方作用：设置该类为spring管理的bean。
Java多线程学习笔记：从基础到深入
资源摘要信息:"多线程笔记_java/多线程_" 知识点： 1. 多线程基础概念： 在Java中，线程（Thread）是程序执行流的最小...以上就是多线程笔记中涉及的知识点，从基础到高级应用，对Java多线程编程有一个全面的覆盖。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Wei *

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值