Java—多线程编程

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

文章目录

多线程的创建

Thread类创建

实现步骤：
1. 创建Thread的子类
2. 重写Thread类中的run方法，设置线程任务
3. 创建Thread的子类对象
4. 调用Thread方法中的start方法，开启新线程调用run方法void start() 导致此线程开始执行; Java虚拟机调用此线程的run方法。

注意：多次启动一个线程是非法的，特别是当前线程结束后，不能再重新启动

// 1. 创建一个Thread类的子类
public class MyThread extends Thread{
    // 2. 继承Thread类重写run方法
    @Override
    public void run(){
        for (int i = 0; i < 20; i++) {
            System.out.println("run:" + i);
        }
    }
}

    public static void main(String[] args) {
        MyThread mt = new MyThread();
        mt.start();

        for (int i = 0; i < 20; i++) {
            System.out.println("main:" + i);
        }
    }

执行以上代码可以看到一个进程一个main进程共同执行，实现了多线程

线程名获取

方法一：
1. 使用Thread中的方法getName（）
String getName() 返回此线程的名称。

public class MyThread01 extends Thread {
    @Override
    public void run() {
        String name = getName();
        System.out.println(name); 
    }
}

    public static void main(String[] args) {
        MyThread01 mt = new MyThread01();

        mt.start(); //Thread-0

        MyThread01 mt2 = new MyThread01();
        mt2.start(); //Thread-1

方法二：
可以获取当前正在执行的线程，
使用线程中的方法getName()获取线程名称

static Thread currentThread()
返回当前正在执行的线程对象的引用

public class MyThread01 extends Thread {
    @Override
    public void run() {
        Thread thread = Thread.currentThread();
        System.out.println(thread); 
    }
}

public static void main(String[] args) {
        MyThread01 mt = new MyThread01();

        mt.start(); // Thread[Thread-0,5,main]

        MyThread01 mt2 = new MyThread01();
        mt2.start(); //Thread[Thread-1,5,main]

    }

获取主线程名称需要先获取当前正在执行的 线程然后再getName，则可以用以下方法：

public class MyThread01 extends Thread {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()); 
    }
}

public class Demo02Thread {
    public static void main(String[] args) {
        MyThread01 mt = new MyThread01();

        mt.start(); //Thread-0

        MyThread01 mt2 = new MyThread01();
        mt2.start(); //Thread-1

        System.out.println(Thread.currentThread().getName()); //main
    }
}

设置线程名称

方法一：
使用Thread中的setName（名字）

方法二：
创建带参构造方法，参数传递线程名称：
使用父类的带参构造方法，把线程名称传递给父类，让父类给子线程起名字
Thread(String name) 分配新的Thread对象

public class MyThread extends Thread{
    public MyThread() {
    }

    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

    public static void main(String[] args) {
        MyThread mt = new MyThread();
        mt.setName("dada");
        mt.start();

        MyThread mt2 = new MyThread("aaa");
        mt2.start();

    }

sleep

public static void sleep(long millis)
使当前正在执行的线程以指定的毫秒数暂停

	public static void main(String[] args) {
        // 模拟秒表
        for (int i = 1; i <= 60; i++) {
            System.out.println(i);

            // 使用Thread类的Sleep方法让程序睡眠1秒钟
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

实现Runnable接口创建

java.long.Runnable
Runnable接口应由任何类实现，其实例将由线程执行。 该类必须定义一个无参数的方法，称为run 。

java.long.Thread类的构造方法
Thread(Runnable target) 分配一个新的 Thread对象。

实现步骤：
1.创建一个Runnable接口的实现类
2.在实现类中重写Runnable接口的run方法，设置线程任务
3.创建一个Runnable接口的实现类对象
4.创建Thread类对象，构造方法中传递Runnable实现类对象
5.调用Thread类中的start方法

public class RunnableImpl implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
    }
}


public class Demo01Runnable {
    public static void main(String[] args) {

        RunnableImpl rn = new RunnableImpl();
        Thread t = new Thread(rn);
        t.start();

        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
    }
}

实现Runnable创建多线程的好处：
1.避免了单继承的局限性
一个类只能继承一个类，类继承了Thread类就不能继承其他类
实现了Runnable接口，还可以继承其他的类，实现其他的接口
2.增强了程序的扩展性，降低了程序的耦合性（解耦）
实现Runnable接口的方式，把设置线程的任务和开启新线程进行了分离（解耦）

实现类中，重写了run方法：用来设置线程任务
创建Thread类对象，调用start方法：开启新线程

匿名内部类创建

格式：

new 父类/接口（）{
        重复父类/接口中的方法
    }

public static void main(String[] args) {
        // 线程的父类使Thread
        new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 20; i++) {
                    System.out.println(Thread.currentThread().getName()+":"+i);
                }
            }
        }.start();

        //线程的接口
        Runnable r = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 20; i++) {
                    System.out.println(Thread.currentThread().getName() + ":---" + i);
                }
            }
        };
        new Thread(r).start();

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

多线程安全问题

假设有一家电影院买票，如果只有一个窗口买票，不会出现卖出去的票有重复的座位或者不存在的座位，就相当于之前的单线程程序，而现在使用了多线程如果不对其同步代码进行约束则会出现上述问题，例如：

public class RunnableImpl implements Runnable{
    private int ticket = 100;
    @Override
    public void run() {
        while (true){
            if (ticket>0){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 买票
                System.out.println(Thread.currentThread().getName()+"正在卖第"+ticket+"张票");
                ticket--;
            }
        }
    }
}

    public static void main(String[] args) {
        RunnableImpl run = new RunnableImpl();
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        t0.start();
        t1.start();
        t2.start();
    }

在这里插入图片描述
在这里插入图片描述
如图所示会出现重复票，不存在的票情况，这是因为当运行到RunnableImpl的if语句后 t0 进入sleep，此时 t1,t2 也可能会进入里面，其中一个先sleep结束进行了减一操作，而其他已经经过了 if 判断，唤醒时不需要判断就可以继续向下，这样就产生了不存在的票 如果三个线程同时唤醒就出现了重复的票

同步代码块解决安全感问题

解决线程安全问题一：使用同步代码块
格式:

    synchronized(锁对象){
        可能会出现线程安全问题的代码（访问了共享数据的代码）
    }

注意：
1.通过代码块中的锁对象，可以使用任意的对象
2.但是必须保证多个线程使用的锁对象是同一个
3.锁对象作用：把同步代码块所著，只让一个线程在同步代码块中执行

public class RunnableImpl implements Runnable{
    private int ticket = 100;

    // 创建锁对象
    Object obj = new Object();

    @Override
    public void run() {
        while (true){
            synchronized (obj){
                if (ticket>0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    // 买票
                    System.out.println(Thread.currentThread().getName()+"正在卖第"+ticket+"张票");
                    ticket--;
                }
            }
        }
    }
}

主函数与之前相同。

原理：
线程抢夺cpu执行权，当一个程序抢到执行权进入同步代码块，这时会首先看synchronized代码中是否有锁对象，如果有就可以进入到锁对象执行

在一个线程进入到锁对象执行时，如果其他对象进入到同步代码块，这是synchronized代码中没有锁对象，会进入堵塞状态，直到这个线程释放

使用同步方法解决安全问题

解决线程安全问题而：使用同步方法：
步骤：
1. 把访问了共享数据的代码抽取出来，放到一个方法中
2. 在方法上添加synchronized修饰符

格式：

修饰符 synchronized 返回值类型 方法名（参数列表）{
    可能会出现共享数据的代码
}

同步方法：

public class RunnableImpl implements Runnable{
    private static int ticket = 100;

    // 创建锁对象
    Object obj = new Object();

    @Override
    public void run() {
        while (true){
            payTicket();
        }
    }

    

    /*
        定义一个同步方法
     */
    public synchronized void payTicket(){
            if (ticket>0){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 买票
                System.out.println(Thread.currentThread().getName()+"正在卖第"+ticket+"张票");
                ticket--;
            }
    }

    public /*synchronized*/ void payTicket(){
        synchronized (this){
            if (ticket>0){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 买票
                System.out.println(Thread.currentThread().getName()+"正在卖第"+ticket+"张票");
                ticket--;
            }

        }
    }
}

同步静态方法：

public class RunnableImpl implements Runnable{
    private static int ticket = 100;

    // 创建锁对象
    Object obj = new Object();

    @Override
    public void run() {
        while (true){
            payTicket();
        }
    }

    /*
        定义一个静态方法
        锁对象不是this
        锁对象是本类的class属性-->class文件对象
     */

    public static/* synchronized*/ void payTicket(){
        synchronized (RunnableImpl.class){
            if (ticket>0){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 买票
                System.out.println(Thread.currentThread().getName()+"正在卖第"+ticket+"张票");
                ticket--;
            }
        }

    }

}

Lock解决安全问题

解决线程安全问题三：Lock锁
java.util.concurrent.locks.lock接口
lock实现提供了比synchronized方法和语句可获得的更广泛的锁定操作

实现方法：
void lock() 获得锁。
void unlock() 释放锁。
java.util.concurrent.locks.ReentrantLock impl Lock接口

使用步骤：
1. 在成员位置创建一个ReentrantLock对象
2. 在可能出现安全问题的代码前调用Lock接口中的方法lock获取锁
3. 在可能出现安全问题的代码后调用Lock接口中的方法unlock释放锁

public class RunnableImpl implements Runnable{
    private int ticket = 100;

    // 1. 在成员位置创建一个ReentrantLock对象
    Lock l = new ReentrantLock();

    @Override
    public void run() {
        while (true){
            // 2. 在可能出现安全问题的代码前调用Lock接口中的方法lock获取锁
            l.lock();
            if (ticket>0){
                try {
                    Thread.sleep(30);
                    // 买票
                    System.out.println(Thread.currentThread().getName()+"正在卖第"+ticket+"张票");
                    ticket--;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    //        3. 在可能出现安全问题的代码后调用Lock接口中的方法unlock释放锁
                    l.unlock(); // 无论程序是否异常都会把锁释放，提高程序效率
                }

            }
Rich_Z_b_f
关注
专栏目录
Java多线程编程
05-02
Java多线程编程是Java开发中的重要组成部分，它允许程序同时执行多个任务，极大地提高了程序的效率和响应性。在Java中，多线程主要通过`Thread`类和并发工具来实现，接下来我们将深入探讨这些关键知识点。 1. **...
Java多线程编程总结
01-31
要认识多线程就要从操作系统的原理说起。以前古老的DOS操作系统（V6.22）是单任务的，还没有线程的概念，系统在每次只能做一件事情。比如你在copy东西的时候不能rename文件名。为了提高系统的利用效率，采用批处理来...
JAVA多线程编程技术PDF
08-28
这份“JAVA多线程编程技术PDF”是学习和掌握这一领域的经典资料，涵盖了多线程的全部知识点。 首先，多线程的核心概念包括线程的创建与启动。在Java中，可以通过实现Runnable接口或继承Thread类来创建线程。创建后...
Java多线程编程技术
03-26
《Java多线程编程核心技术》建议猿友们读两遍，因为其写得没有那么抽象，第一遍有些概念不是很理解，可以先跳过并记录起来，第一遍阅读的目的主要是了解整个架构。第二遍再慢慢品味，并贯穿全部是指点来思考，并将...
Java多线程编程实战指南(核心篇)
07-17
Java多线程编程实战指南(核心篇) 高清pdf带目录 随着现代处理器的生产工艺从提升处理器主频频率转向多核化，即在一块芯片上集成多个处理器内核（Core），多核处理器（Multicore Processor）离我们越来越近了――如今...
C语言 | 第十章 | 函数 作用域
ZJC744575的博客
10-05 1209
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
JDK1.0主要特性
FoolRabbit的专栏
10-06 356
JDK1.0主要特性。
JavaScript ArrayBuffer的读写与类型转换
白瑕 的博客
10-01 519
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
Netty 相比原生IO模型的优势
lssffy的博客
10-09 326
Java提供了多种I/O模型，每种模型都有其适用的场景和特点，随着网络应用需求的变化，I/O模型也在不断发展。阻塞I/O（BIO，Blocking I/O）传统的I/O模型，使用简单，但每次I/O操作都会阻塞线程。每个请求需要独立的线程来处理，这在并发请求较少时问题不大，但在高并发情况下，线程资源将成为瓶颈。非阻塞I/O（NIO，Non-Blocking I/O）引入了多路复用技术，一个线程可以处理多个连接，避免了BIO中每个连接占用一个线程的问题。通过Selector。
JAVA开源项目 旅游管理系统 计算机毕业设计
as230627的博客
10-03 1350
旅游管理系统基于Springboot框架、JAVA编程语言、MYSQL数据库开发完成，“操作简单，功能实用”这是本软件设计的核心理念，本系统力求创造最好的用户体验。
Spring Boot 整合 Minio
cmh1008611的博客
10-09 621
5‌‌.Optional‌是Java 8引入的一个新的容器对象，它提供了非常丰富的API，主要是为了解决空指针异常的问题。Optional类允许你创建一个可能为null的值的容器，从而避免了直接使用null值可能导致的空指针异常。自动处理异常：在使用 @SneakyThrows 注解的方法中，如果抛出任何类型的检查性异常（即编译器要求显式捕获或声明的异常），Lombok 会自动将其包装成运行时异常（RuntimeException），从而避免了需要显式捕获或声明这些异常的麻烦。可以用于自动装配和依赖注入。
Apache Flink Dashboard
最新发布
qq_41081716的博客
10-09 217
并行度，可以运行一个任务实例。已完成、取消和失败的作业数量。
Python并发编程(1)——Python并发编程的几种实现方式
一点
10-03 1066
Python 并发编程是指在 Python 中编写能够同时执行多个任务的程序。并发编程在任何一门语言当中都是比较难的，因为会涉及各种各样的问题，在Python当中也不例外。Python 提供了多种方式来实现并发，包括多线程（threading）、多进程（multiprocessing）、异步编程（asyncio），以及一些高级用法concurrent.futures和第三方库如gevent。
springboot 用request.setAttribute 传值到控制层
qq56477643的博客
10-09 51
【代码】springboot 用request.setAttribute 传值到控制层。
古典舞在线交流：SpringBoot平台实现与优化
2401_85341950的博客
10-04 655
在这段时期里，我查找了很多相关的资料，查阅了很多Java的相关文献，结合自己的经验，设计了这个古典舞在线交流平台，虽然每个学期学校都会针对动手练习进行相应的课程设计，但是在古典舞在线交流平台的具体设计中还是遇到了一些小问题，但在不断的学习、研究中都将问题一一解决，在一一克服的过程中，我也得到了成长，知识和经验也得到了丰富，这对我来说是一笔巨大的财富。这次设计也大大提高了我的动手的能力，让我在学习中充分体会到了探索的乐趣，享受成功的创作过程，在本次设计过程中汲取的东西，是一笔宝贵的财富，让我受益匪浅。
JavaScript Set基础与实战应用
软考鸭
10-01 411
Set是JavaScript中一个非常有用的数据结构，它提供了一种存储唯一值的方式。通过掌握Set的基本用法、特性以及高级操作，你可以在开发过程中更加灵活地处理集合数据。无论是去除数组中的重复元素，还是进行集合运算，Set都能提供简洁而高效的解决方案。
【微服务】服务调用 - OpenFeign（day6）
weixin_73060900的博客
10-06 1237
对远程调用组件OpenFeign进行了简单介绍.
Spring Boot驱动的现代医院管理系统
2401_85761003的博客
10-07 1110
6、网络上的客户端和服务器可以用来编程任何独立的编程环境，也有中国，GB2312，BIG5，日文写作，一般基金，用于支持多国语言，并且可以嵌入在数据表和其他软件shift_jis访问柱可以用作的名称。2、支持多种操作系统AIX的，FreeBSD下，HP-UX，Linux和Mac OS中，Novell公司的Netware，OpenBSD系统，OS/2裹时，Solaris，Windows等。编程语言，如C, C ++，Python和Java的，的Perl，PHP，埃菲尔铁塔，Ruby和Tcl的。
python：PyPDF2 将多个图片转换为pdf，再合并成一个PDF文件
belldeep的专栏
10-05 574
python：from PyPDF2 import PdfMerger 将多个图片转换为pdf，再合并成一个PDF文件。
Java多线程编程实战指南
"Java多线程编程深入详解" 在Java编程中，多线程是并发执行任务的关键技术，它使得程序能够同时处理多个任务，提高了系统资源的利用率和程序的响应速度。本书深入讲解了Java多线程编程的各个方面，旨在帮助读者理解...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Rich_Z_b_f

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

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

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

打赏作者

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

抵扣说明：

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

余额充值