Java 多线程

已于 2023-05-09 14:22:19 修改
阅读量57 收藏
点赞数
分类专栏： JAVA 文章标签： java Powered by 金山文档
于 2023-03-12 21:40:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51679737/article/details/129233788
版权
互斥：通过竞争，独占资源，各线程彼此之间不需要知道对方的存在，乱序执行。
同步：协调多个相互关联的线程按一定的顺序，合作完成任务，彼此之间知道对方存在。

  1. 创建线程

（1）继承自Thread类

public class MyThread extends Thread{
    @Override
    public void run() {
        //代码
    }
}

class Test{
    public static void main(String[] args){
        MyThread myThread = new MyThread();
        myThread.run();     //普通的方法调用
        myThread.start();   //相当于开启一个新进程，该线程与main线程是平级的
    }
}
每新建一个线程，都会在JVM中新建一个栈空间，且每个线程都会争夺进程的CPU。

（2）实现Runnable接口

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        String name = Thread.currentThread().getName();
        //获取当前进程的名字
    }
}

class TestRunnable{
    public static void main(String[] args){
        MyRunnable myRunnable = new MyRunnable();   //线程的执行体
        Thread thread = new Thread(myRunnable, "窗口1");
        thread.start(); //启动进程
    }
}
优点：
①Runnable更适合处理共享资源。若共享资源定义为static，Thread也能处理。
②避免Java中单继承的局限性。
③实现解耦，代码可以被多个线程共享

（3）Callable接口

class MyCallable implements Callable<Integer>{  //此时泛型要指定具体类型，如Integer、String
    @Override
    public Integer call() throws Exception {
        //代码
        return null;
    }
}

class TestCallable{
    public static void main(String[] args) {
        ExecutorService pool = Executors.newFixedThreadPool(3);
        MyCallable myCallable = new MyCallable();
        Future<Integer> result = pool.submit(myCallable);
        pool.shutdown();
        Integer value = result.get();   //获取线程的结果
    }
}

  1. 线程常用方法

（1）设置线程优先级

MyThread myThread = new MyThread();
myThread.setName("线程1");
//为线程设置名字
myThread.setPriority(Thread.NORM_PRIORITY);  
//为线程设置优先级
//Java优先级1~10，值越大，优先级越高
//Thread.MAX_PRIORITY = 10
//Thread.MIN_PRIORITY = 1
//Thread.NORM_PRIORITY = 5
优先级高的线程会获得较多的运行机会。

（2）线程休眠

MyThread t = new MyThread();
t.start();                 //开启的进程才能休眠   
try {
    Thread.sleep(1000);    //让当前进程休眠n秒，非main线程
} catch (InterruptedException e) {
    e.printStackTrace();
}   

（3）线程让步

class A extends Thread{
    @Override
    public void run() {
        //代码
    }
}

class B extends Thread{
    @Override
    public void run() {
        Thread.yield();
        //yield()无法真正达到线程让步的目的
        //yield()可以使当前进程放弃CPU的执行权，重新回到可执行状态，但马上又会去竞争CPU的执行权
    }
}

class test1{
    public static void main(){
        new A().start();
        new B().start();
    }
}

（4）线程合并

主线程的执行会被打断，直到新加入的线程执行完毕，主线程才继续。

class A extends Thread{
    @Override
    public void run() {
        //代码
    }
}

class Test{
    public static void main(){
        A a = new A();
        a.start();
        try {
            a.join();    //线程让步
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

  1. 守护线程

当主线程结束时，守护线程也会结束。

class Test{
    public static void main(){
        MyThread t = new MyThread();
        t.setDaemon(true);  //设为守护线程
        t.start();
    }
}

  1. 线程的生命周期

（1）新建状态New

当线程对象创建之后进入新建状态。

（2）就绪状态Runnable

当执行start()时，线程进入就绪状态，此时线程随时等待CPU调度执行。

（3）运行状态Running

当CPU开始调度就绪状态的线程时，该线程进入运行状态。

（4）阻塞状态Blocked

运行状态的线程由于某种原因，暂时放弃CPU的使用权，停止运行，此时线程进入阻塞状态。

  1. 等待阻塞

运行状态的线程执行wait()。

  1. 同步阻塞

线程获取synchronized同步锁失败。此时锁被其他线程占有。

（5）死亡状态Dead

线程执行完毕，或发生异常时，线程进入死亡状态。

  1. 线程安全

CPU在高速切换过程中，线程在任何时刻都有可能被抢占CPU的执行权。

原子操作：不可分割的多步操作被视为一个整体。

（1）同步代码块

synchronized，一种同步锁，可以保证多个线程访问共享数据时，同一时刻只会有一个线程操作，其余线程进入阻塞状态。

class SynThread extends Thread{
    Object lock = new Object();
    //锁对象，任意类型对象都可以充当锁对象
    //多个线程都有使用同一个锁，即同一个对象

    @Override
    public void run() {
        synchronized (lock){
            //CPU保证只有一个线程能执行这段代码
        }
    }
}
//多线程可以使用以下方法创建对象
//.class文件加载进内存的时候，只会创建一个该类对象
synchronized(MyThread.class){
    //代码
}

（2）同步方法

class SynThread extends Thread{
    public synchronized void test(){
        //此时，锁对象为this
        //synchronized也可以修饰static方法
    }

    @Override
    public void run() {
        test();
    }
}

（3）Lock

JDK5以后，新加Lock接口，实现类ReentrantLock和synchronized有一样的功能。

class Test{
    private Lock lock = new ReentrantLock();
    void test(){
        lock.lock();    //加锁
        try {
            //有线程安全问题的代码
        }catch (Exception ex){
            //错误处理
        }finally {
            lock.unlock();  //解锁
        }
    }
}

  1. 线程通信——等待唤醒机制

class Test{
    public static void main(String[] args) {
        Object lock = new Object();
        new Thread(
                new Runnable() {
                    @Override
                    public void run() {
                        synchronized (lock){    //获得锁
                            try {
                                lock.wait();    //释放锁，线程进入等待池
                                //代码
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }, "线程一").start();

        new Thread(
                new Runnable() {
                    @Override
                    public void run() {
                        synchronized (lock){    //获得锁
                            lock.notify();      //唤醒一个等待最久的线程。唤醒后的线程进入就绪状态，将重新竞争CPU的执行权
                        }
                    }
                }, "线程二").start();
    }
}
wait(1000*n) //等待n秒
sleep(long m) //在时间内不会释放锁
lock.notifyAll() //唤醒所有等待中的线程

  1. 线程池

一个可以容纳多个线程的容器，其中的线程可以反复使用，省去创建和销毁线程的步骤。

顶级接口java.util.concurrent.Executor，是执行线程的工具。
真正的线程池接口java.util.concurrent.Executors。 
class Test{
    public static void main(String[] args) {
        //方式一，创建固定长度的线程池对象，
        ExecutorService pool1 = Executors.newFixedThreadPool(3);
        MyRunnable myRunnable = new MyRunnable();   //创建一个Runnable接口子类对象
        pool1.submit(myRunnable);   //提交，提交一次就是启动一个线程
        pool1.shutdown();   //关闭线程池
        
        //方式二，创建一个可缓存，大小按需求变化的线程池
        ExecutorService pool2 = Executors.newCachedThreadPool();
        
        //方式三，创建一个单线程的线程池，程序按顺序进行
        ExecutorService pool3 = Executors.newSingleThreadExecutor();
        
        //方式四，创建一个固定长度的线程池，并以延迟或定时的方式进行
        ScheduledExecutorService s = Executors.newScheduledThreadPool(3);
        s.schedule(myRunnable, 3, TimeUnit.SECONDS);//启动一个线程，并延迟3秒执行
        while(!s.isTerminated()){
            //当线程没有执行完毕，main线程将会进入循环
        }
        s.shutdown();   //关闭线程池，但不会马上终止程序
    }
}

  1. 线程安全集合

（1）CopyOnWriteArrayList

线程安全的ArrayList。写入时，先copy一个容器副本，再添加新元素，最后替换引用到副本。

（2）CopyOnWriteArraySet

线程安全的ArraySet。

（3）ConcurrentHashMap

线程安全的HashMap。多线程的时候可能出现异常。

不倒葱
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java 多线程
11-07
### Java多线程知识点详解 #### 一、Java Thread 概念 在Java中，**线程**是一种轻量级的进程，它是程序执行流的最小单元。一个标准的Java应用通常至少包含一个线程，即主（Main）线程。Java支持多线程编程，这...
Java多线程详解及示例
07-20
Java多线程编程是提升程序性能和响应性的关键技术。理解多线程的概念，掌握线程的创建、同步、通信、死锁避免等核心知识点，以及合理使用线程池，对于编写高效、稳定的并发程序至关重要。通过实践，开发者可以更好地...
多线程批量处理任务（解耦，提高效率，保证事务一致性）
陈落月的博客
09-02 2797
@hello，很久没更了，最近上班太忙了，还有楼主太懒。。。。今天给大家分享一篇多线程批量处理数据库数据的解耦解决方案。。文章有点糙。。望谅解。 多线程批量处理任务（解耦，提高效率，保证事务一致性） 知识点 1.aop 2.线程池 3.线程通信 4.事务 案例：批量导入更新数据库数据，当用户导入上千条时，由于业务复杂，最终的执行sql相当于数据条数的十倍以上，更新时长超过80s最终超时异常。 我的优化方案（有更好的方案分享给博主哟，欢迎指正）：1-异步处理，提示用户稍候查看，后台处理；2-同步处理，并行处
浅谈Java程序中对象解耦的方式
Wren的博客
04-09 781
在以上代碼中，UserLoginServlet依赖于UserJDBCDao，如果UserJDBCDao使用的技术需要更换，则可能创建新的UserMyBatisDao来替换原有的UserJDBCDao，则以上代码中UserJDBCDao就需要被替换为UserMyBatisDao。需要调整的只有工厂类中的方法的返回值，而工厂类的修改只需要一次即可。对象的耦合性即对象的依赖性。“高内聚、低耦合”是每个程序员追求的目标，随着编程技术的发展，必将有更多更好的方法来降低程序耦合性，程序解耦方法的研究还需要不断深入。
JAVA系列 多线程 Thread类 耦合 线程调度 如何创建线程 弱耦合 完全解耦 思维结构整理
Ultravioletrays的博客
01-08 493
这估计是我JAVA系列 基础知识点梳理的最后一篇文章了吧之后一段时间 我打算去看看之前承诺更新的JAVA的一些项目了 然后我要好好玩一段时间游戏 然后跟某些好朋友见面 所以后面会忙一点然后就是很多同学 六级还没有考 估计很多人是开学再考把 这个假期就不要玩的太厉害了 没事就看看我之前写的关于CET6 整理的文章。
Java中的耦合和解耦
Radish
05-22 2564
耦合 百度百科： 耦合也叫块间联系，指软件系统结构中各模块间相互联系紧密程度的一种度量。模块之间联系越紧密，其耦合性就越强，模块之间越独立则越差。 Java中耦合: 例如在web开发中，表现层需要持有业务层的对象，业务层中需要持有持久层的对象，这种关系是很强的依赖关系。 代码如下： 业务层：(在包service下) package top.radish.service public class AccountService { // 持久层的AccountDao对象 private AccountD
Java springboot主线程拆分多子线程任务，完成后继续主线程
rgbhi的博客
10-15 2290
开发中遇到了一个问题，我们数据库里的数据是加密过的，读取、计算等等操作，都会有对原始数据进行加解密的操作。 问题是单次操作数据量有几千条，如果是单线程进行解密的话，时间实在是有点慢。这是不能忍受的，所以，我们需要对其进行并发加解密。 我的具体思路是这样的，因为加解密的动作，其实是对一个长List进行单项的加解密的动作。 可以将这个长List进行分段区分，生成多个子线程的任务，每个子线程只执行长List中的一段区间内的加解密，多个子线程都完...
Java多线程编程总结
01-31
要认识多线程就要从操作系统的原理说起。以前古老的DOS操作系统（V6.22）是单任务的，还没有线程的概念，系统在每次只能做一件事情。比如你在copy东西的时候不能rename文件名。为了提高系统的利用效率，采用批处理来...
java多线程
05-02
Java多线程是Java编程中的核心概念，它允许程序同时执行多个任务，提高了程序的效率和响应速度。在Java中，实现多线程有两种主要方式：通过实现`Runnable`接口和继承`Thread`类。 1. 实现Runnable接口 当一个类...
Java多线程读取大文件
12-22
【Java多线程读取大文件】是一种优化的文件处理策略，特别适用于处理大型文本文件。在传统的单线程I/O操作中，读取大文件可能导致内存溢出（OOM），尤其是在尝试一次性加载整个文件到内存时。为了避免这个问题，我们...
java多态如何实现解耦_如何基于Spring使用工厂模式实现程序解耦
weixin_36248959的博客
02-24 409
这篇文章主要介绍了如何基于Spring使用工厂模式实现程序解耦,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下1、 啥是耦合、解耦？既然是程序解耦，那我们必须要先知道啥是耦合，耦合简单来说就是程序的依赖关系，而依赖关系则主要包括1、 类之间的依赖2、 方法间的依赖比如下面这段代码：public class A{public int i;}publi...
深入浅出Java并发多线程（2）- 实现线程方式
一角残叶的博客
11-29 348
1 实现多线程的方法有几种 2种 public class RunnableStyle implements Runnable { public static void main(String[] args) { Thread thread = new Thread(new RunnableStyle()); thread.start(); } @Override public void run() { System
Java 模块解耦的设计策略
江帅帅
08-16 280
我们学习了如何实现两种模式来解耦 Java 模块。这两种方法都使消费者模块依赖于抽象，这始终是软件组件设计中所需的功能。当然，每一种都有其优点和缺点。对于第一个，我们得到了很好的解耦，但我们必须创建一个额外的工厂类。对于第二个，为了使模块解耦，我们必须创建一个额外的抽象模块并使用 Service Loader API 添加新的间接级别。
Java线程之间的通信
Otar
06-18 193
通信方式一： volatile 变量的写 - 读 这一点是利用了 volatile 写 和 读之间规则，也就是：volatile变量写完以后，会将写好的变量值立刻刷新到主存里面， volatile变量被读之前，会先从主存中里面读取这个 volatile变量的值，说到底，volatile变量 就是借助于规则和主存这两个必要条件来进行线程间的通信。如果 volatile 变量 和 其他变量...
Java 高级应用-多线程-（一）实现 Runnable 接口与继承 Thread 类
weixin_45817985的博客
05-30 3086
Java 高级应用-多线程-实现 Runnable 接口与继承 Thread 类
J031_使用TCP协议支持与多个客户端同时通信
lzn20161229的博客
08-03 410
使用TCP协议支持与多个客户端同时通信。
C++ - 函数重载
最新发布
jiaowenjie的专栏
08-06 167
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
SpringBoot+Vue图书(图书借阅)管理系统-附项目源码与配套文档
m0_74283290的博客
08-03 1244
本论文阐述了一套先进的图书管理系统的设计与实现，该系统采用Java语言，结合现代Web开发框架和技术，旨在为图书馆提供高效、灵活且用户友好的资源管理解决方案。系统利用Spring Boot框架为核心，整合MyBatis ORM工具，以及MySQL数据库，构建了一个高性能、可扩展的后端服务。前端界面则采用了Vue.js框架，以提供流畅的用户交互体验。论文首先进行了详尽的需求分析，确定了系统的核心功能，包括图书的添加、编辑、删除、查询，读者的注册、登录、个人信息管理，以及图书的借阅、归还、续借流程。
枚举工具类
qq_43049583的博客
08-04 397
java枚举工具类
Java多线程深度解析
"《Java多线程详解》- 汪文君" 本书是关于Java多线程编程的深度解析，作者汪文君分享了他在工作中和学习中的理解和实践经验。书中内容详细介绍了多线程的基本概念、Java对多线程的支持以及如何在实际编程中运用多...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值