Java高级编程—多线程

最新推荐文章于 2024-06-29 11:59:11 发布
最新推荐文章于 2024-06-29 11:59:11 发布
阅读量147 收藏
点赞数
分类专栏： Java学习 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_45057667/article/details/120312650
版权

1.基本概念

1.1 进程和线程

进程(proess)：是程序的一次动态执行过程。有他自己的生命周期。进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域。

线程(thread)：线程是比进程更小的执行单位。若一个进程同一时间内并行执行多个线程，就是支持多线程的。

1.2 单核与多核

单核CPU实际是一种假的多线程，因为在一个时间单元内，它只能执行一个线程的任务。只是CPU单元时间特别短，感觉不出来。

多核才能更好地发挥多线程的效率。

一个Java应用程序，至少有三个线程：main()主线程，gc()垃圾回收线程，异常处理线程。

1.3 并行与并发

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

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

2.线程的创建和使用

2.1 java语言的多线程的实现：

1）继承Thread类：

package com.company;
/**
 * @author conghuhu
 * @create 2021-09-15 18:33
 */
/**
 * 多线程的创建，方式一：继承Thread类
 *      1.创建一个继承于Thread类的子类
 *      2.重写run()方法
 *      3.创建Thread类的子类的对象
 *      4.调用start()方法
 */
class MyThread extends Thread {
    @Override
    public void run() {
        for(int i=0; i<100;i++){
            if(i%2 == 0){
                System.out.println(i);
            }
        }
    }
}

public class ThreadTest {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();
        for (int i = 0; i < 100; i++) {
            System.out.println("hello"+i);
        }
    }
}

2）实现Runnable(Callable)接口来实现：

  1. 创建一个实现了Runnable接口的类
  2. 实现类去实现Runnable中的抽象方法：run()
  3. 创建实现类的对象
  4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
  5. 通过Thread类的对象调用start()
class MThread implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(i);
        }
    }
}

public class MyRunnable {
    public static void main(String[] args) {
        MThread mThread = new MThread();
        Thread t1 = new Thread(mThread);
        t1.start();
    }
}
  1. 两种创建方式的对比
  • Runnable方式可以有效避免单继承的局限。
  • Runnable方式可以更加方便地实现数据共享的概念。
  • 开发中优先选择Runnable。

2.2 线程的常用方法

  • void start()：启动当前线程；调用当前线程的run();
  • run()：线程被调度时执行，通常需要重写Thread类中的方法
  • String getName()：获取当前线程的名称
  • void setName(String name)：设置当前线程的名称
  • static Thread currentThread()：静态方法，获取当前线程对象
  • yeild()：释放当前CPU执行权，让给其他线程
  • join()：在线程a中调用线程b，此时a线程进入阻塞状态，直到线程b完全执行以后，线程a才结束阻塞状态。
  • sleep(mm)：线程等待
  • isAlive()：判断线程是否存活

2.3 线程的调度

调度策略：

  • 时间片
  • 抢占式：高优先级的线程抢占CPU

Java的调度方法

  • 同优先级线程组成先进先出队列(先到先服务)，使用时间片策略
  • 对高优先级，使用优先调度的抢占式策略

线程的优先等级

  • MAX_PRIORITY：10
  • MIN_PRIORITY：1
  • NORM_PRIORITY：5

涉及的方法

  • getPriority()：返回线程优先值
  • setPriority(int newPriority)：改变线程的优先级

3.线程的生命周期

  1. 创建状态
  2. 就绪状态：创建线程对象后，调用该线程的start()方法启动线程。当线程启动后，线程进入就绪状态。此时，线程将进入线程队列排队，等待CPU服务。
  3. 运行状态
  4. 堵塞状态
  5. 终止状态

4.线程的同步

4.1 线程的安全问题

  • 多个线程执行的不确定性引起执行结果的不稳定
  • 比如，多个线程对账本的共享，会造成操作的不完整性，会破坏数据

4.2 同步操作

一个代码块中的多个操作在同一时间段内只能有一个线程进行，其他线程要等待此线程完成后才可以继续执行。即使线程出现了阻塞，其他线程也要等待。

在Java中，我们通过同步机制，来解决线程的安全问题。

方式一：同步代码块

synchronized(同步监视器){
	// 需要同步的代码
	// 操作共享数据的代码，即需要被同步的代码
	// 同步监视器：俗称 锁。任何一个类的对象，都可以充当锁。
	// 要求：多个线程必须要共用同一把锁。
}


class Window1 implements Runnable {
    private int ticket = 20;
    @Override
    public void run() {
        while(true){
            synchronized (this){
                if(ticket>0){
                    try {
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ": 票号"+ticket);
                    ticket--;
                }else{
                    System.out.println("票卖光了");
                    break;
                }
            }
        }
    }
}

public class WindowTest {
    public static void main(String[] args) {
        Window1 window1 = new Window1();
        Thread t1 = new Thread(window1);
        Thread t2 = new Thread(window1);
        Thread t3 = new Thread(window1);
        t1.start();
        t2.start();
        t3.start();
    }
}

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

class Window1 implements Runnable {
    private int ticket = 20;
    @Override
    public void run() {
        while (true) {
            buyTicket();
        }
    }
    private synchronized void buyTicket() { // 此时锁是默认的，this
        if (ticket > 0) {
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + ": 票号" + ticket);
            ticket--;
        }
    }
}

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

        Thread t1 = new Thread(window1);
        Thread t2 = new Thread(window1);
        Thread t3 = new Thread(window1);
        t1.start();
        t2.start();
        t3.start();
    }
}

同步操作，解决了线程安全的问题。但是在操作同步代码时，只能有一个线程参与，其他线程等待，相当于是一个单线程，效率低。

4.3 死锁

死锁：不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁。出现死锁后，所有的线程都处于阻塞状态。

解决：

  • 专门的算法、原则
  • 尽量减少同步资源的定义
  • 尽量避免嵌套同步

4.4 Lock（推荐）

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

class Window2 implements Runnable {
    private int ticket = 20;

    // 1. 实例化Lock
    private ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            try {
                //2.调用lock()方法
                lock.lock();
                if (ticket > 0) {
                    try {
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ": 票号" + ticket);
                    ticket--;
                } else {
                    System.out.println("票已卖完");
                    break;
                }
            }finally {
                // 3.解锁
                lock.unlock();
            }
        }
    }
}

public class LockTest {
    public static void main(String[] args) {
        Window2 window2 = new Window2();
        Thread t1 = new Thread(window2);
        Thread t2 = new Thread(window2);
        Thread t3 = new Thread(window2);
        t1.start();
        t2.start();
        t3.start();
    }
}

面试题：synchronized与lock的不同？

  1. lock需手动锁定，手动解锁。synchronized是代码块执行完毕，释放。
  2. 使用Lock锁，JVM将花费较少的诗句连调度线程，性能更好。并且具有更好地扩展性(提供更多的子类)。

5.线程的通信

例子：使用两个线程打印1-100，两个线程交替打印

class Print implements Runnable {
    private int number = 1;
    @Override
    public void run() {
        while (true) {
            synchronized (this) {
                notify(); // 唤醒线程
                if (number <= 100) {
                    System.out.println(Thread.currentThread().getName() + ":" + number);
                    number++;
                    try {
                        // 使得调用如下wait方法的线程进入阻塞状态
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    break;
                }
            }
        }
    }
}

public class MessageTest {
    public static void main(String[] args) {
        Print print = new Print();
        Thread t1 = new Thread(print);
        Thread t2 = new Thread(print);

        t1.setName("线程1");
        t2.setName("线程2");

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

线程通信常用的方法：
wait()：线程进入阻塞状态，并释放锁
notify()：唤醒被wait的一个线程
notifyAll()：唤醒所有进程

说明：

  1. 这三个方法必须使用在同步代码块或同步方法中
  2. 这三个方法的调用者必须是同步代码块或同步方法中的监视器，否则报错

6.JDK5.0新增线程创建方式

callable 后期补充

7.使用线程池

线程池：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁，实现重复利用。

JDK5.0起提供了线程池相关API：ExecutorService 和 Executors

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 NumberThread2 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 150; 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);
        // 2.执行指定的线程操作。
        service.execute(new NumberThread()); // 适合使用于Runnable
        service.execute(new NumberThread2());
//        service.submit(); // 适合适用于callable
        // 3.关闭线程池
        service.shutdown();
    }
}

好处：

  1. 提高相应速度（减少创建线程的时间）
  2. 降低资源消耗（重复利用线程池中的线程，不需要每次都创建）
  3. 便于线程管理
    - corePoolSize: 核心池的大小
    - maximumPoolSize：最大线程数
    - keepAliveTime：线程没有任务时最多保持多长时间后会终止
public class ThreadPool {
    public static void main(String[] args) {
        // 1.提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        // 需要获取ExecutorService 的类，去管理线程池
        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
        service1.setCorePoolSize(20);
        // 2.执行指定的线程操作。
        service.execute(new NumberThread()); // 适合使用于Runnable
        service.execute(new NumberThread2());
        // 3.关闭线程池
        service.shutdown();
    }
}
前端渣硕
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java 高级 - 多线程编程
m0_69424697的博客
05-31 119
一、进程和线程 在 java 语言中最大的特点就是支持多线程的开发（也是为数不多支持多线程开发的语言），如果对多线程没有一个全面而且细致的了解，在以后一定存在严重的技术缺陷。 进程：传统的 dos 是单进程处理，允许一个程序执行，后来到了 Windows 时代，出现了多线程的设计。表示在一个时间段上可以运行多个程序，并且这些程序将进行资源的轮流抢占。在同一时间点上，只有一个程序执行，后来有了多核 CPU 的实现。可以实现在同一时间点，多个程序同时执行。 ...
JAVA多线程编程技术PDF
08-28
在Java编程领域，多线程是一项至关重要的技术，它允许程序同时执行多个任务，从而提高系统资源的利用率和程序的响应速度。这份“JAVA多线程编程技术PDF”是学习和掌握这一领域的经典资料，涵盖了多线程的全部知识点...
Java高级编程——多线程
qq_40840749的博客
05-12 111
目录 1.1 程序、进程、线程的基本概念 1.2 线程的创建和使用 1.3 线程的生命周期 1.4 线程的同步 1.5 线程的通信 1.1 程序、进程、线程的基本概念 程序：一段静态的代码 进程：程序的一次执行过程。进程是动态的，有自身的创建、运行到消亡。一个进程可以有多个线程。 线程：进程可进一步细化为线程，是一个程序内部的一条执行路径。多个线程共享进程的堆和方法区，但每个线程有自己的程序计数器、虚拟机栈、本地方法栈。 1.2 线程的创建和使用 （1）方式一：继承于Thread类.
Educoder--Java高级特性 - 多线程基础（1）使用线程
weixin_45803282的博客
05-18 9071
第一题 请仔细阅读右侧代码，根据方法内的提示，在Begin - End区域内进行代码补充，具体任务如下： 使用继承Thread类的方式创建一个名为 ThreadClassOne 的类，重写的run方法需要实现输出0-10之间的奇数，输出结果如下： 1 3 5 7 9； 使用实现Runnable接口的方式创建一个名为ThreadClassTwo的类，重写run方法，编写start方法，run方法需要实现打印0-10之间的偶数，输出结果如下： 0 2 4 6 8 10 ThreadClassOne /**
EduCoder Java高级特性 - 多线程基础（1）使用线程
热门推荐
知足且上进，温柔而坚定
02-28 1万+
第1关：创建线程 任务描述 本关任务：创建一个Java线程执行特定任务。 编程要求 请仔细阅读右侧代码，根据方法内的提示，在Begin - End区域内进行代码补充，具体任务如下： 使用继承Thread类的方式创建一个名为 ThreadClassOne 的类，重写的run方法需要实现输出0-10之间的奇数，输出结果如下： 1 3 5 7 9； 使用实现Runnable接口的方式创建一个名为ThreadClassTwo的类，重写run方法，编写start方法，run方法需要实现打印0-
Java高级编程——多线程（基本概念+线程的创建及应用）
ou_yang_mu_ling的博客
08-28 429
目录1、基本概念：程序、进程、线程1.1程序（program）1.2进程（process）1.3线程（thread）1.4并行与并发并行并发1.5使用多线程的优点1.6多线程的应用场景2、线程的创建和应用（重点）2.1java.lang.Thread2.1.1通过继承Thread创建线程2.1.2创建过程中的两个问题2.1.2.1问题一：不能直接调用run()方法来执行线程2.1.2.2 问题二：不能对同一线程执行两次start()2.1.3 创建Thread的匿名子类2.1.4Thread的常用方法se
Java高级编程之多线程
哈哈L先生
08-05 350
Java多线程 一、程序、进程、线程 1. 程序(program) 概念：是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码。 2. 进程(process) 概念：程序的一次执行过程，或是正在运行的一个程序。 说明：进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域 3. 线程(thread) 概念：进程可进一步细化为线程，是一个程序内部的一条执行路径。 说明：线程作为调度和执行的单位，每个线程拥独立的运行栈和程序计数器(pc)，线程切换的开销小。 内存结构： 进程可
JavaJava高级编程多线程PPT教案学习.pptx
09-30
JavaJava高级编程多线程PPT教案学习.pptx
计算机软件及应用JavaJava高级编程多线程PPT课件.pptx
10-09
计算机软件及应用JavaJava高级编程多线程PPT课件.pptx
计算机软件及应用JavaJava高级编程多线程PPT学习教案.pptx
10-11
计算机软件及应用JavaJava高级编程多线程PPT学习教案.pptx
Java多线程编程
05-02
Java多线程编程是Java开发中的重要组成部分，它允许程序同时执行多个任务，极大地提高了程序的效率和响应性。在Java中，多线程主要通过`Thread`类和并发工具来实现，接下来我们将深入探讨这些关键知识点。 1. **...
配置系统PATH环境变量
最新发布
weixin_44626980的博客
06-29 321
PATH环境变量在操作系统中起着非常重要的作用，特别是在命令行或脚本中执行程序时，系统会根据PATH环境变量中定义的路径查找可执行文件。当用户在命令行或脚本中输入一个命令时，系统会根据PATH环境变量中定义的路径依次查找对应的可执行文件，如果找到则执行。本文详细介绍了如何配置系统的PATH环境变量，包括在Windows和Linux系统中的操作步骤。在Linux系统中，可以通过编辑shell配置文件来配置PATH环境变量，常用的shell配置文件包括.bashrc、.bash_profile等。
Java面试题:Redis为什么速度快
qq_55630615的博客
06-25 543
因为Redis是纯内存操作,执行速度非常快,性能的瓶颈是网络延迟而非执行速度I/O多路复用模型主要就是实现了高效的网络请求。
微服务和kafka
m0_51586984的博客
06-26 1203
ZooKeeper 是一个开源的分布式协调服务，ZooKeeper框架最初是在“Yahoo!"上构建的，用于以简单而稳健的方式访问他们的应用程序。后来，Apache ZooKeeper成为Hadoop，HBase和其他分布式框架使用的有组织服务的标准。例如，Apache HBase使用ZooKeeper跟踪分布式数据的状态。ZooKeeper 的设计目标是将那些复杂且容易出错的分布式一致性服务封装起来，构成一个高效可靠的原语集，并以一系列简单易用的接口提供给用户使用。
基于weixin小程序智慧物业系统的设计
ing65768的博客
06-27 274
管理员账户功能包括：系统首页，个人中心，管理员管理，用户管理，员工管理，房屋管理，缴费管理，车位管理，报修管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。工作人员账号功能包括：系统首页，维修管理，维修指派，公告管理，轮播图信息。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
解决Java中的数组越界异常的技术
weixin_44627014的博客
06-26 373
通过本文的讨论，我们了解了如何有效地处理Java中的数组越界异常。预防异常的发生，合理使用异常处理机制以及考虑使用集合类来替代数组，是确保Java应用程序稳定性和可靠性的关键步骤。
编译正则表达式模式re.compile
liujingwei8610的专栏
06-27 158
print("【执行】pattern.findall('这里有123个苹果和45个橘子')")result = pattern.findall('这里有123个苹果和45个橘子')print(f"【显示】pattern={pattern}")print(f"【显示】result={result}")根据给定的Python代码，哪个选项是正确的？A选项：返回值可以进行search操作。B选项：返回值可以进行match操作。D选项：参数为要编译的正则表达式模式。C选项：参数为要搜索的字符串。
Java 中的访问修饰符及其适用范围
liangzai215的专栏
06-25 634
public就像是开放的公园，对所有人开放。private好比你的私人日记，只有你能看。protected则是家庭相册，家人和继承者可以看到。而默认访问级别，则像是一扇未上锁的后门，只对同在一个包的“家人”开放。合理使用这些访问修饰符，可以帮助你构建更加安全、模块化和易于维护的代码。就像管理家中的物品一样，通过设置合适的访问权限，让每个部分各司其职，既保护了隐私，又促进了内部的合作与协调。
Java多线程编程深入详解.docx
10-24
"Java多线程编程深入详解文档包含了如何创建线程、线程的状态、资源锁、线程间通信、线程组、线程池、单例模式以及生产者消费者模式等多个关键知识点。提供了多进程多线程的定义和Java对其支持的介绍。" 在Java编程...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值