JAVA多线程基础知识总结归纳

最新推荐文章于 2024-11-10 08:43:33 发布
最新推荐文章于 2024-11-10 08:43:33 发布
阅读量72 收藏
点赞数
分类专栏： 笔记 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mingzibeizhancao/article/details/115190128
版权
本文深入探讨了Java中的多线程概念，包括进程与线程的定义，线程的基本API，以及线程的创建方式。详细阐述了线程池的重要性和使用，如ExecutorService和Executors接口，以及它们的不同实现。此外，文章还讨论了线程安全问题，提供了三种解决线程安全的方法：同步代码块、同步方法和显式锁，并通过卖票示例进行了说明。最后总结了显式锁与隐式锁的区别，并给出了处理线程安全问题的判断步骤。
摘要由CSDN通过智能技术生成

多线程

1.引言

计算机的配置越来越高，CPU计算速度越来越快，如果能够将一个单一执行的程序进行优化，分解成多个小块（几乎同时）进行，能够大大提高开发效率，对CPU的利用率也能够提升一布。

2.进程和线程

进程：进程是执行程序的一个过程，一个程序从打开到关闭算做一个进程。进程是一个动态的过程，每个进程都有自己独立的一块内存空间，有自己的生存周期。

线程：进程中的一个执行任务（控制单元），负责当前进程中程序的执行。一个进程至少有一个线程，一个进程可以运行多个线程，多个线程可共享数据。与进程不同的是同类的多个线程共享进程的堆和方法区资源，但每个线程有自己的程序计数器、虚拟机栈和本地方法栈，所以系统在产生一个线程，或是在各个线程之间作切换工作时，负担要比进程小得多，也正因为如此，线程也被称为轻量级进程。

并发和并行

并发：发生在同一时间间隔内，即理解为一个人同时做很多事

并行：发生在同一时刻，即理解为不同的人同时在做不同的事

3.线程的基本API

1.start():1.启动当前线程2.调用线程中的run方法

2.run():通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中

3.currentThread():静态方法，返回执行当前代码的线程

4.getName():获取当前线程的名字

5.setName():设置当前线程的名字

6.yield():主动释放当前线程的执行权

7.join():在线程中插入执行另一个线程，该线程被阻塞，直到插入执行的线程完全执行完毕以后，该线程才继续执行下去

8.stop():过时方法。当执行此方法时，强制结束当前线程。

9.sleep（long millitime）：线程休眠一段时间

10.isAlive（）：判断当前线程是否存活

4.线程的创建方式

1.继承Thread抽象类

​ 创建一个线程的第二种方法是创建一个新的类，该类继承 Thread 类，然后创建一个该类的实例。

​ 继承类必须重写 run() 方法，该方法是新线程的入口点。它也必须调用 start() 方法才能执行。

2.继承Runnable接口

​ 实现Runnable接口，重写run方法

3.继承Callable接口

    1. 创建 Callable 接口的实现类，并实现 call() 方法，该 call() 方法将作为线程执行体，并且有返回值。
    1. 创建 Callable 实现类的实例，使用 FutureTask 类来包装 Callable 对象，该 FutureTask 对象封装了该 Callable 对象的 call() 方法的返回值。
    1. 使用 FutureTask 对象作为 Thread 对象的 target 创建并启动新线程。
    1. 调用 FutureTask 对象的 get() 方法来获得子线程执行结束后的返回值。

范例：线程基本创建

/**
 * Runnable接口
 */
public class ThreadDemo{
    public static void main(String[] args) {
        Lock lock = new ReentrantLock();
        Thread t =  new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("我是谁");
            }
        });
        t.start();
    }
}

线程池

背景：经常创建和销毁，使用量特别大的资源，比如并发情况下的线程，对性能影响很大。

思路：提前创建好多个线程，放入线程池之，使用时直接获取，使用完放回池中。可以避免频繁创建销毁，实现重复利用。类似生活中的公共交通工具。（数据库连接池）

好处：提高响应速度（减少了创建新线程的时间）

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

便于线程管理

ExecutorService 和 Executors

ExecutorService:真正的线程池接口。常见子类ThreadPoolExecutor.

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

Futuresubmit(Callable task):执行任务，有返回值，一般又来执行Callable

void shutdown（）：关闭连接池。

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

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

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

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

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

范例：创建一个定长线程池

/**
 *定长线程池
 * （长度为指定数值）
 * 任务加入后的执行流程：
 *          1.判断线程池中是否有空闲线程
 *          2.存在则使用
 *          3.不存在且线程池未满，则添加新的线程进入线程池，并执行
 *          4.不存在且线程池已满，则排队等待空闲线程
 */
public class DemoFixedThreadPool {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        executorService.execute(new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"锄禾");
            }
        }));
    }
}

范例：创建一个缓存线程池

/**
 *缓存线程池
 * （长度没有限制）
 * 任务加入后执行流程：
 *     1.判断线程池中是否又空闲线程
 *     2.有则使用
 *     3.没有则创建新的线程添加到线程池，然后使用
 */
public class DemoCachedThreadPool {
    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newCachedThreadPool();
        executorService.execute(new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"楚河");
            }
        }));
    }
}

范例：创建一个周期线程池

/**
 * 周期任务 定长线程池
 * 执行流程：
 *    1.判断线程是否为空闲线程
 *    2.存在则使用
 *    3.不存在空闲线程，且线程池未满的情况下，则创建线程并放入线程池，然后使用
 *    4.不存在空闲线程，且线程池以满的情况下，则等待线程池存在空闲线程
 */
public class Demo周期线程池 {
    public static void main(String[] args) {
        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(2);
        executorService.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"楚河");
            }
        },5,1, TimeUnit.SECONDS);
        executorService.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"楚河");
            }
        },5, 1,TimeUnit.SECONDS);
        executorService.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"楚河");
            }
        },5, 1,TimeUnit.SECONDS);
    }
}

5.线程安全

创建三个窗口卖票，总票数为100张票

1.卖票过程中，出现了重票（票被反复的卖出，ticket未被减少时就打印出了）错票。

2.问题出现的原因：当某个线程操作车票的过程中，尚未完成操作时，其他线程参与进来，也来操作车票。（将此过程的代码看作一个区域，当有线程进去时，装锁，不让别的线程进去）

因此，多个线程对同一个共享数据进行操作时，线程没来得及更新共享数据，从而导致另外线程没得到最新的数据，从而产生线程安全问题。

Java中，有三种方式解决这个问题：

5.1同步代码块

同步监视器（俗称：锁）：任何一个的对象都可以充当锁。（但是为了可读性一般设置英文成lock）当锁住以后只能有一个线程能进去（要求:多个线程必须要共用同一把锁，比如火车上的厕所，同一个标志表示有人）

范例：

/**
 * 解决线程不安全,同步代码块
 */
public class Demo1 {
    public static void main(String[] args) {
        Runnable ticket = new Ticket();
        new Thread(ticket).start();
        new Thread(ticket).start();
        new Thread(ticket).start();
    }

    static class Ticket implements Runnable{
        private int count = 10;
        Object o = new Object();//创建一个Object类型的变量，充当锁
        @Override
        public void run() {
            while (true){//通过锁使得线程排队完成，获得锁的线程继续走，没有获得锁的线程等待
                synchronized (o) {
                   if (count>0) {
                       System.out.println("正在卖票");
                       try {
                           Thread.sleep(1000);
                       } catch (InterruptedException e) {
                           e.printStackTrace();
                       }
                       count--;
                       System.out.println(Thread.currentThread().getName() + "出票成功，当前票数剩余" + count);
                   }else {
                       break;
                   }
               }
            }
        }
    }
}

5.2同步方法

用同步方法，对方法进行synchronized关键字修饰

将同步代码块提取出来成为一个方法，用synchronized关键字修饰此方法。

对于runnable接口实现多线程，只需要将同步方法用synchronized修饰

而对于继承自Thread方式，需要将同步方法用static和synchronized修饰，因为对象不唯一（锁不唯一）

/**
 * 同步方法
 */
public class Demo2 {
    public static void main(String[] args) {
        Runnable ticket = new Ticket();
        new Thread(ticket).start();
        new Thread(ticket).start();
        new Thread(ticket).start();
    }

    public static class Ticket implements Runnable{
        private int count = 10;
        @Override
        public void run() {
            while (true){
                sale();
            }
        }

        private synchronized void sale(){
                if (count>0) {
                    System.out.println("正在卖票");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    count--;
                    System.out.println(Thread.currentThread().getName()+"出票成功，当前票数剩余"+count);
                }
        }
    }
}

5.3显式锁

实际定义出来一个锁。

/**
 * 显式锁
 */
public class Demo3 {
    public static void main(String[] args) {
         Runnable ticket = new Ticket();
         new Thread(ticket).start();
         new Thread(ticket).start();
         new Thread(ticket).start();
    }

    public static class Ticket implements Runnable{
        private int count = 10;
        Lock lock = new ReentrantLock();

        @Override
        public  void run() {
            while (true) {
                lock.lock();
                if (count > 0) {
                    System.out.println("正在卖票");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    count--;
                    System.out.println(Thread.currentThread().getName() + "出票成功，当前票数剩余" + count);
                }
                lock.unlock();
            }
        }
    }
}

总结：显式锁Lock和隐式锁synchronized的区别？

1.获取和释放操作：

Lock需要进行实例，获取操作和释放操作，而synchronized不需要任何获取和释放的操作，只需要加上修饰符即可

2.Lock是通过API来获取的，而synchronized是由JVM来维护

3.Lock可以通过lock和unlock随时管理开始和中断，而synchronized则不能中断

4.Lcok可以通过赋值，true为公平锁，false为非公平锁，而synchronized则固定为非公平锁

值得一提的是，公平锁和非公平锁，举个例子，高中下课所有人跑步到食堂买饭，先到的人买了一份饭，而后面的人在等待，这个时候先到的那个人的同学发来了一条信息，然后先到的同学又买了一份，后面的同学只能再等，这就是非公平，而公平就是买完之后大家重新回到教室再次跑步到食堂买饭，先到先得。

优先使用顺序：

LOCK-同步代码块-同步方法

判断线程是否有安全问题，以及如何解决：

1.先判断是否多线程

2.再判断是否有共享数据

3.是否并发的对共享数据进行操作

4.选择上述三种方法解决线程安全问题

输给生活
关注
专栏目录
Java基础知识总结（2021版）
学Java，找哪吒
01-09 25万+
前言 大家好，我是素小暖，2012年毕业，2016年通过培训转行java开发，今天2021年1月9日，转行之路跌跌绊绊，蓦然回首，已经满满的4年工作经验了？但感觉知识还是相当的匮乏，没自信，也许是努力程度还不够吧。很感谢CSDN，因为是它给了我学习的动力，之前写了一篇记录CSDN博客访问量的文章，也许大家感觉很幼稚，但真的很有用，很有效果，仿佛磕了药一样，努力学习，进步。 2020年，是我较为成功的一年，工作上，跳了槽，涨了工资；学习上，啃了几本名著（Effective Java、重构 改善既.
Java多线程知识点总结
学习笔记。
05-28 749
一、进程与线程 程序：程序是指令和数据的有序集合，本身没有任何运行的含义，是一个静态概念 进程：是执行程序的一次执行过程，是一个动态概念。是系统资源分配的单位。（程序执行起来就变成了进程） 线程：通常一个进程中可以包含多个线程。线程是CPU调度和执行的单位。 二、线程如何创建 有三种创建模式 1.继承Thread类 本质上Thread类实现了Runnable接口。 使用调用run方法与调用start方法的不同，run方法是被当做普通方法，按照程序执行顺序在主线程（main）中正常执行，但是start
java 多线程 结果汇总_java多线程细节归纳汇总
weixin_39842682的博客
02-24 634
1、前言一直以来，用过多线程，但是，在某些细节方面总是不注意，现特将一些基本知识点进行归纳汇总，以备后面的使用。2、Java多线程的实现方式JAVA多线程实现方式主要有三种：继承Thread类、实现Runnable接口、使用ExecutorService、Callable、Future实现有返回结果的多线程。其中前两种方式线程执行完后都没有返回值，只有最后一种是带返回值的。2.1继承Thread...
多线程重点知识归纳总结。
yzh2776680982的博客
06-08 2072
一、线程相关概念 1、程序 程序是一个指令序列。是为完成特定任务、 用某种语言编写的一组指令的集合。简单的说:就是我们写的代码 它以某些程序设计语言编写，运行于某种目标结构体系上。打个比方，程序就如同以英语（程序设计语言）写作的文章，要让一个懂得英语的人（编译器）同时也会阅读这篇文章的人（结构体系）来阅读、理解、标记这篇文章。一般的，以英语文本为基础的计算机程序要经过编译、链接而成为人难以解读，但可轻易被计算机所解读的数字格式，然后放入运行。 2、进程 ............
Java基础知识点总结归纳，超级全面！
2401_83641392的博客
03-25 2317
Java程序在执行子类的构造方法之前，如果没有用super()来调用父类特定的构造方法，则会调用父类中“没有参数的构造方法”。因此，如果父类中只定义了有参数的构造方法，而在子类的构造方法中又没有用super()来调用父类中特定的构造方法，则编译时将发生错误，因为Java程序在父类中找不到没有参数的构造方法可供执行。解决办法是在父类里加上一个不做事且没有参数的构造方法。由于静态方法可以不通过对象进行调用，因此在静态方法里，不能调用其他非静态变量，也不可以访问非静态变量成员。
Java基础知识点总结.docx
04-03
Java是一种广泛使用的面向对象的编程语言，其基础知识涵盖了多个方面，包括语法、面向对象特性、异常处理、多线程、I/O流、网络编程、反射技术、设计模式以及JVM等核心概念。以下是对这些知识点的详细说明： 一、...
Java 多线程学习总结归纳（附代码）
01-09
以上内容涵盖了Java多线程的基础知识，包括创建、同步、终止、线程安全和并发控制等方面。通过实际的代码实践，可以深入理解并掌握这些概念，提升多线程编程的能力。同时，文档中的代码示例能帮助读者更好地理解和...
java八股文归纳，包含基础知识、集合框架、多线程与并发等
11-07
Java的“八股文”通常指的是Java开发者在面试中常被问到的一系列...压缩包文档是对Java八股文的详细归纳，包含基础知识、集合框架、多线程与并发、Java虚拟机（JVM）、Java Web开发、Java框架与技术栈、其他相关知识。
JAVA多线程基础知识总结
weixin_43907440的博客
04-21 201
JAVA线程 程序，进程，线程 程序：为了完成特定任务，用某种语言编写的一组指令集和，即指一段静态代码，静态对象 进程：后台在运行的程序，程序的一次执行过程，比如QQ.exe，有其自身的生命周期：产生、存在和消亡的过程，程序是静态的，进程是动态的，进程作为资源分配的范围，系统在运行时会为每一个进程分配不同的内存区域。 线程：进程中的每个活动—线程，比如说QQ中的各项操作应用，同时进行聊天，语音，文...
Java多线程基础知识总结
av12138的博客
06-07 204
Java多线程基础知识总结 1. 进程 VS 线程 进程：是操作系统分配资源的最小单位；是程序的一次动态执行。 线程：是操作系统调度的最小单位。 2. 创建线程 继承Thread类 public class ThreadTest { public static void main(String[] args) { Thread t1=new MyThread(); t1.start(); } } class MyTh
Java基础知识总结归纳
qq_31716541的博客
06-08 4798
Java基础知识总结归纳
JAVA-01-变量
LJH_laura_li的博客
11-08 418
在方法、构造函数或块内部定义的变量。
2024年华为OD机试真题-查找充电设备-C++-OD统一考试（E卷）
面试高手的博客
11-08 255
某个充电站，可提供n个充电设备只，每个充电设备均有对应的输出功率任意个充电设备组合的输出功率总和，均构成功率集合P的1个元素功率集合P的最优元素，表示最接近充电站最大输出功率pmax 的元素。每一题都含有详细的解题思路和代码注释，精编c++、JAVA、Python三种语言解法。当充电设备输出功率50、20、20组合时，其输出功率总和为90，最接近充电站最大充电输出功率，因此最优元素为90。所有充电设备的输出功率组合，均大于充电站最大充电输出功率30，此时最优元素值为0。第 2 行为每个充电设备的输出功率。
基于 SpringBoot 实现QQ邮箱验证码注册功能
2301_79201049的博客
11-06 654
找到并开通以下的邮件协议服务，而且服务开启也较为简单，需要我们发送一个短信到指定的号码，开启后平台会提供一个授权码，一定要记住这个授权码，发邮件的时候需要这个。host 是根据服务主机区分，网易邮箱是 smtp.163.com, qq邮箱是 smtp.qq.com。其中的 username 是你第一步中操作的邮箱账号，nickname 是接收者收到邮件中显示的发件人。发送邮件的核心依赖是 mail ，由于该项目还涉及其他依赖就全都导进来了。（1）首先打开QQ邮箱，点击设置并来到账号页面。
Java基于小程序公考学习平台的设计与实现（附源码，文档）
chusheng1840的博客
11-09 1000
Java基于小程序公考学习平台的设计与实现，小程序公考学习平台使用Java语言进行编码，使用Mysql创建数据表保存本系统产生的数据。系统可以提供信息显示和相应服务，其管理小程序公考学习平台信息，查看小程序公考学习平台信息，管理小程序公考学习平台。总之，小程序公考学习平台集中管理信息，有着保密性强，效率高，存储空间大，成本低等诸多优点。它可以降低信息管理成本，实现信息管理计算机化。关键词：小程序公考学习平台；Java语言；Mysql。
java_方法重写/覆盖(override)
HHppGo的博客
11-07 335
方法覆盖（重写）就是子类有一个方法，和父类的某个方法的名称、返回类型、参数一样，那么我们就说子类的这个方法覆盖了父类的方法。
并发编程的基础：深入理解内存屏障（Memory Barriers）
2401_86353562的博客
11-06 1005
内存屏障是一种基础语言，在不同的计算机架构下有不同的实现细节。本文主要在x86_64处理器下，通过Linux及其内核代码来分析和使用内存屏障对大多数应用层开发者来说，“内存屏障”（memory Barrier）是一种陌生，甚至有些诡异的技术。实际上，他机制常被用在操作系统内核中，用于实现同步、驱动程序利用它，能够实现高效的无锁数据结构，提高多线程程序的性能表现。本文首先探讨了内存屏障的必要性，之后介绍如何利用内存屏障实现一个无锁唤醒振荡器（队列），用于在多个线程间进行高效的数据交换。
在 C# 中，如何实现观察者模式？
Leo的博客
11-06 491
观察者模式是一种设计模式，它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。当该主题对象的状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。这个模式常用于事件处理系统、通知系统等场景。
ArkTS--应用状态
最新发布
qq_63946637的博客
11-10 513
本文旨在帮助大家学习鸿蒙中的LocalStorage和AppStorage
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值