多线程

最新推荐文章于 2024-10-01 09:29:45 发布
最新推荐文章于 2024-10-01 09:29:45 发布
阅读量95 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48971493/article/details/107525603
版权

文章目录

多线程

线程的创建方式

实现Runnable接口

public class Test {

    public static void main(String[] args){
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable,"t1");	//第一个参数传入实现了Runnable的类，第二个参数设置线程名
        thread.start();
    }
}

class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 1; i < 10; i++){
            System.out.println("这是分支线程第" + i + "次打印");
        }
    }
}

也可以使用匿名内部类的方式：

public class Test {

    public static void main(String[] args){
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i < 10; i++){
                    System.out.println(i);
                }
            }
        }, "t1");
        thread.start();
    }
}

继承Thread

public class Test {

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

class MyThread extends Thread{
    @Override
    public void run() {
        System.out.println("这是分支线程");
    }
}

实现Runnable接口与继承Thread相比有如下几点优势：

1、可以避免单继承带来的局限性

2、任务与线程是分离的，提高了程序的健壮性

3、线程池只能接受Runnable类型的任务，

4、通过创建任务，给线程分配的方式实现多线程，更适合多个线程执行相同任务的场景

Callable

public class Test {

    public static void main(String[] args) {
        FutureTask<Integer> futureTask = new FutureTask<>(new MyCallable());
        Thread t1 = new Thread(futureTask);
        t1.start();
    }
}

class MyCallable implements Callable<Integer>{	//
    @Override
    public Integer call() throws Exception {
        System.out.println("这是重写的call方法");
        return 1;
    }
}

与上述两种线程创建方式不同，实现callable接口的线程执行完会产生一个返回值

其中call方法会抛出异常，但是run方法不会

Thread类

常用方法

String getName(); //获取当前线程名称

void start(); //启动线程

static void sleep(long millis, int nanos); //让线程休眠millis毫秒+nanos纳秒（第二个参数可以不填）

void setDaemon(boolean on); //将此线程标记为守护(daemon)线程或用户线程

获取、修改当前线程名

public class Test {

    public static void main(String[] args){
        Thread thread = Thread.currentThread();//获取执行这段代码的当前线程对象
        thread.getName();//获取线程名
        thread.setName("t1");//设置线程名
    }
}

线程的中断

public class Test {

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                //循环执行任务
                while (true) {
                    for (int i = 1; i < 10; i++) {
                        System.out.println(Thread.currentThread().getName() + ":" + i);
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            System.out.println("响应中断，结束线程");
                            return;
                        }
                    }
                }
            }
        });

        thread.start();//启动线程

        Thread.sleep(3000);//main线程先睡3秒

        thread.interrupt();//中断线程，执行catch代码块
                           /* 注：线程会继续执行当前任务，直到执行到以下方法时才会响应中断
                                java.lang.Object#wait()
                                java.lang.Object#wait(long)
                                java.lang.Object#wait(long, int)
                                java.lang.Thread#sleep(long)
                                java.lang.Thread#interrupt()
								java.lang.Thread#interrupted()*/
    }
}

线程安全

同步代码块

格式：

synchronized (object o){
            
}

Java中，每个对象都有一个锁标记

当第一个线程执行到同步代码块时，会占有括号中的这个对象锁

后续线程执行到此处时会先观察，括号中的对象锁是否被占用，如果被占用就排队等待

当线程执行完同步代码块后会自动释放掉占用的括号中的对象锁

特点：

​ 锁的粒度比较小

同步方法

将synchronized关键字加在方法上，格式：

public synchronized void say(){
    
}

表示锁的this，即调用该方法的对象

当线程执行到某对象的say()方法时，该对象的对象锁被占用

synchronized也可以用在静态方法上，表示锁的当前类的class对象（类名.class）

同步代码块和同步方法都是隐式锁（即自动上锁，自动解锁）

Lock显式锁

public static void main(String[] args) {
        //任务对象
        Runnable r = new Runnable() {
            private int i = 1;
            //创建锁对象
            private Lock l = new ReentrantLock();
            @Override
            public void run() {
                while (true){
                    l.lock();//当线程执行到此处时会观察l对象是否被锁住，如果是就排队，否则就将l对象锁住并继续往下执行
                    try {
                        if (i < 10){
                            System.out.print("第" + i + "次");
                            System.out.println(Thread.currentThread().getName() + "正在执行");
                            i++;
                        }else {
                            break;
                        }
                    }finally {
                        l.unlock();//锁的释放要放在finally代码块里，防止占用资源
                    }
                }
            }
        };

        new Thread(r, "t1").start();
        new Thread(r, "t2").start();
        new Thread(r, "t3").start();

}

公平锁与非公平锁

公平锁：按先来后到排队获取锁

非公平锁：同时竞争一把锁

上述三种锁的方式都是非公平锁

公平锁的实现方式：

Lock l = new ReentrantLock(true);//创建lock对象时传入一个参数，默认是false表示非公平锁

线程的状态

New：新建状态，调用start方法之后进入可运行状态

Runnable：可运行状态（未抢夺到CPU时间片而陷入等待的线程，依然属于Runnable状态）

Blocked：阻塞状态（没能进入同步代码块的线程会进入该状态）

Waiting：等待状态（调用了wait方法、Thread.join方法会使线程进入该状态）

Timed_Waiting：超时等待状态（调用了Thread.sleep、wait带时间参数的方法、join带时间参数的方法会进入该状态）

Terminated：结束状态

线程池

缓存线程池

public class Test {

    public static void main(String[] args) {
        /**
         * 缓存线程池.
         * (长度无限制)
         * 执行流程:
         * 1. 判断线程池是否存在空闲线程
         * 2. 存在则使用
         * 3. 不存在,则创建线程 并放入线程池, 然后使用
         */
        ExecutorService service = Executors.newCachedThreadPool();
        //向线程池中 加入 新的任务
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程的名称:"+Thread.currentThread().getName());
            }
        });        
    }
}

定长线程池

public class Test {

    public static void main(String[] args) {

        /**
         * 定长线程池.
         * (长度是指定的数值)
         * 执行流程:
         *      1. 判断线程池是否存在空闲线程
         *      2. 存在则使用
         *      3. 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用
         *      4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
         */
        ExecutorService service = Executors.newFixedThreadPool(2);
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程的名称:"+Thread.currentThread().getName());
            }
        });
    }
}

单线程线程池

public class Test {

    public static void main(String[] args) {

        /**
         * 单线程线程池.
         * 执行流程:
         * 1. 判断线程池 的那个线程 是否空闲
         * 2. 空闲则使用
         * 4. 不空闲,则等待 池中的单个线程空闲后 使用
         */
        ExecutorService service = Executors.newSingleThreadExecutor();
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程的名称:"+Thread.currentThread().getName());
            }
        });
    }
}

周期性任务定长线程池

public class Test {

    public static void main(String[] args) {
        /**
         * 周期任务 定长线程池.
         * 执行流程:
         * 1. 判断线程池是否存在空闲线程
         * 2. 存在则使用
         * 3. 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用
         * 4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
         * *
         周期性任务执行时:
         * 定时执行, 当某个时机触发时, 自动执行某任务
         */
        ScheduledExecutorService service = Executors.newScheduledThreadPool(2);
        /**
         * 定时执行
         * 参数1. runnable类型的任务
         * 参数2. 时长数字
         * 参数3. 时长数字的单位
         */
        service.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("俩人相视一笑~ 嘿嘿嘿");
            }
        },5,TimeUnit.SECONDS);
        /**
         * 周期执行
         * 参数1. runnable类型的任务
         * 参数2. 时长数字(延迟执行的时长)
         * 参数3. 周期时长(每次执行的间隔时间)
         * 参数4. 时长数字的单位
         */
        service.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("俩人相视一笑~ 嘿嘿嘿");
            }
        },5,2,TimeUnit.SECONDS);
    }        
}

Lamda表达式

lamda表达式是一种函数式编程思想

在开发过程中经常遇到这样的情况：

在创建线程时，为了实现run方法，要写一堆与run方法的实现无关的代码（即先要创建对象，再通过对象调用方法）

lamda表达式略去了那些无关的要素，只关注于方法

接口中只有一个抽象方法需要被实现的（不是规定接口只能有一个方法），可以使用lamda表达式

语法格式：

() -> {}

由于只有一个方法需要被实现

所以其中的(）表示的是需要被实现的方法后面的括号，有入参就在括号里加上入参

后面的大括号表示需要实现方法的方法体

oo天之涯oo
关注
QT中利用TCP协议实现了一个多线程的文件互传系统
06-09
在QT框架下，利用TCP协议实现一个多线程的文件互传系统是一项常见的任务，它涉及到网络编程、多线程处理以及文件操作等多个方面。本文将深入探讨这些关键知识点。 首先，TCP（Transmission Control Protocol）是一...
java多线程导出excel（千万级别）优化
12-05
Java多线程导出Excel是处理大数据量时的一种高效策略，尤其在面对千万级别的数据时。传统的Apache POI库在处理大规模数据时可能会遇到栈溢出（StackOverflowError）和内存溢出（OutOfMemoryError）等问题，因为这些...
Java多线程实战-从零手搓一个简易线程池(一)定义任务等待队列
热门推荐
qq_35716689的博客
03-25 24万+
开个新坑-手搓简易线程池。本系列文章将从零开始,一步步手工编码实现一个简单但功能完备的线程池。我们将逐步介绍线程池的各个核心组件,并分析它们的作用和实现思路。通过这个过程,我们可以更好地掌握多线程编程的技巧,并培养编码能力和系统性思维。
C# 多线程
05-29 1万+
一、基本概念 1、进程 首先打开任务管理器，查看当前运行的进程： 从任务管理器里面可以看到当前所有正在运行的进程。那么究竟什么是进程呢？ 进程（Process）是Windows系统中的一个基本概念，它包含着一个运行程序所需要的资源。一个正在运行的应用程序在操作系统中被视为一个进程，进程可以包括一个或多个线程。线程是操作系统分配处理器时间的基本单元，在进程中可以有多个线程同时执行代码。进...
C++多线程
weixin_43229348的博客
04-17 3326
1.基础知识 为了提高CPU的使用率，将某些需要耗时较多的任务或是大量IO操作（IO处理速度很慢），采用多线程可以适当的提高程序的执行效率。 C++11之后有了std::thread库，需要引入头文件： 先来介绍Thread的成员函数： # 用来查看当前线程的id thread::get_id() # 检查此线程是否还和主线程连接（已经完成join、detach的线程都是false） thread：：joinable() # 将线程与主线程的连接切断，并且此线程会继续独立执行下去，直到执行结束时候释放分配的
多线程 join 方法
Gonelin的博客
12-22 6304
多线程 join 方法 1.前言 本节对 join 方法进行深入的剖析，主要内容点如下： 了解 join 方法的作用，初步的理解 join 方法的使用带来的效果是学习本节内容的基础； 了解 join 方法异常处理，我们在使用 join 方法是，需要对 join 方法进行有效的异常处理； 通过匿名内部类创建Thread 是我们本节代码示例所使用的的方式，对这种方式的掌握在后续工作中非常重要； 掌握 join 方法如何使用，这是本节的重点内容，也是本节的核心内容； 掌握带参数的 join 方法使用，在后续开发
C语言多线程
微小冷的学习笔记
03-19 9013
在C语言中创建线程方式如下 #include <pthread.h> pthread_create (thread, attr, start_routine, arg) 其中，thread为线程指针；attr为线程属性，默认NULL；start_routine为线程运行函数起始地址；arg为运行函数的参数。无参数时使用NULL。 如果线程成功创建，函数返回0，否则说明创建失败。 当线程完成工作后，若无需继续存在，则会调用pthread_exit函数。也就是说，这个函数可以显式地退出一个线程。
深入理解多线程概念、同步与无锁机制
张彦峰的博客
10-14 4万+
介绍多线程编程的相关概念、同步机制以及无锁编程。从线程的基础概念出发，包括逻辑线程和硬件线程的比较，以及线程、核心和函数的关系。随后，我们探讨了多线程编程的基本原则，包括时间分片、上下文切换、线程安全函数和可重入函数等。接着，我们讨论了为什么需要多线程同步、什么情况需要进行同步以及多线程同步的方式，包括串行化、原子操作和锁等。我们还深入研究了非阻塞的无锁同步机制，如CAS循环和无锁数据结构。最后，我们解释了程序序、内存序、乱序执行、存储缓冲区和失效队列等概念，以帮助更好地理解多线程编程。
多线程详解
weixin_48638578的博客
05-17 3261
文章目录多线程一、基本概念：程序、进程、线程线程二、并行与并发三、多线程优点四、创建多线程方式一：继承Thread五、线程常用方法六、创建多线程方式二：实现Runnable接口七、创建多线程方式三：实现Callable接口 jdk5.0八、线程的生命周期九、三种方法解决线程安全问题十、死锁问题十一、线程通信十二、线程通信的应用：生产者/消费者十三、sleep() 和 wait() 区别十四、线程池使用Executors创建线程池 例： (==不允许使用Executors创建线程池==)使用ThreadPo
python多线程详解（超详细）
世俗的眼光
03-30 21万+
python中的多线程是一个非常重要的知识点，今天为大家对多线程进行详细的说明，代码中的注释有多线程的知识点还有测试用的实例。 import threading from threading import Lock,Thread import time,os ''' python多线程详解 什么是线程？ ...
多线程相关实例（多线程经典应用场景）
瞎琢磨先生の博客
04-22 1万+
转载，from 网络，未能找到原创人员，只找到一个二手转载 https://blog.csdn.net/u013521220/article/details/79648270 一.相关知识： Java多线程程序设计到的知识： （一）对同一个数量进行操作 （二）对同一个对象进行操作 （三）回调方法使用 （四）线程同步，死锁问题 （五）线程通信 等等 二．示例一：三个售票窗口同时出售20张票; 程序分析：1.票数要使用同一个静态值 2.为保证不会出现卖出同一个票数，要java多线程同步锁。 设计思路：1.创.
linux多线程
weixin_46485873的博客
07-09 3110
多线程：所有程序并发运行，多条路径可以同时执行 多线程包括：理解线程并发、线程同步方法、线程安全概念 线程指：进程内部得一条执行路径（从主函数的第一行代码到最后一行）主线程：main 子线程：线程函数 比如：fun.... 进程指：一个正在运行的程序 在linux平台创建线程，是内核提供的头文件#include注意编译的时候要加 -lpthreadpthread_create(线程id，默认的属性可以不设置为NULLL，参数函数); 创建线程子线程如下图 有些时候主线......
Android多线程文件夹下载及断点续传
08-07
在Android开发中，进行大文件下载时，为了提高效率并充分利用设备资源，通常会采用多线程下载技术。此外，为了提升用户体验，断点续传功能也显得尤为重要，尤其是在网络不稳定或者用户中断下载后，可以从上次停止的...
Qt 多线程及简单实例 demo
03-07
Qt 多线程及简单实例 demo。 多线程的几大特点： 1.多线程的执行顺序无法保证，与操作系统的调度策略和线程优先级等因素有关。 2.多线程的切换可能发生在任何时刻、任何地点。 3.多线程对代码的敏感度高，因此对...
Qt界面多线程opencv调用摄像头
05-09
本代码是在qt平台下opencv利用多线程调用摄像头进行实时的视频显示在gui界面上，利用的时QThread的方法，是本人用了一年时间在维护的代码，需要的可以前来下载。当然我这也有qt上位机部分的代码，有需要的可以在评论...
spring-boot 整合 mybatis
m0_72168501的博客
09-29 487
spring boot 整合 mybatis
Java内存布局
最新发布
阿呆的专栏
10-01 769
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
C#基础：掌握控制流语句，构建灵活的程序逻辑
学习和分享
09-28 314
在C#中，控制流语句是用来控制程序执行流程的重要部分。它们允许你根据条件执行不同的代码块，或者重复执行某些代码块直到满足特定条件。
进程管理工具：非daemon进程管理工具supervisor
happy_king_zi的博客
09-29 1099
supervisor是一个 Client/Server模式的系统，允许用户在类unix操作系统上监视和控制多个进程，或者可以说是多个程序。supervisor与launchd，daemontools，runit等程序有着相同的功能，与其中某些程序不同的是，它并不作为“id 为 1的进程”而替代init。相反，它用于控制应用程序，像启动其它程序一样，通俗理解就是，把Supervisor服务管理的进程程序，它们作为supervisor的子进程来运行，而supervisor是父进程。
Linux多线程编程详解：pthread实践与指南
Linux多线程编程指南是一份由Sun Microsystems提供的文档，专注于在Linux环境下使用POSIX线程库（pthread）进行并发编程。这份文档涵盖了多线程编程的基础概念、设计原则以及在Solaris操作系统中的应用。 1. **概述...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值