java多线程（超详细讲解）下篇

已于 2024-03-21 07:56:49 修改
阅读量1.5k 收藏 11
点赞数 57
文章标签： java 开发语言
于 2024-03-20 20:06:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AE_BD/article/details/136886117
版权

本章继续讲多线程

目录

一、线程同步

当多个线程共享数据时，由于CPU负责线程的调度，所以程序无法精确地控制多线程的交替次序。如果没有特殊控制，则多线程对共享数据的修改和访问将导致数据的不一致。

1、为什么需要线程同步

上一章学习的线程都是独立且异步运行的，也就是说每个线程都包含了运行时所需要的数据或方法，不必关心其他线程的状态和行为。但是经常会有一些同时运行的线程需要操作共同数据，此时就要考虑其他线程的状态和行为；否则，不能保证程序运行结果的正确性。

示例：

public class Storage {
    public final int MAX_COUNT = 3;//最大库存三车

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }

    private int count = 0;//库存量

    //对外向果商发货
    public void get() {
        if (count > 0) {
            count--;//1.修改数据
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            //2.显示数据
            System.out.println(Thread.currentThread().getName() + "：采购了第" + (MAX_COUNT - count) + "车水果");
        }
    }

    //果园向仓库供货
    public void put() {
        if (count == 0) {
            count = MAX_COUNT;//1.修改数据
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println(Thread.currentThread().getName() + "：已向仓库发送" + count + "车水果");//显示数据
        }
    }
}

class BusiThread implements Runnable {
    Storage storage;

    public BusiThread(Storage storage) {
        this.storage = storage;
    }

    public void run() {
        while (true) {
            this.storage.get();//仓库供应一车水果
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

class FarmerThread implements Runnable {
    Storage storage;

    public FarmerThread(Storage storage) {
        this.storage = storage;
    }
    public void run(){
        while (true) {
            this.storage.put();//向仓库运送一车水果
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}
class Test7{
    public static void main(String[] args) {
        Storage storage=new Storage();//创建仓库类对象
        Thread busi1=new Thread(new BusiThread(storage),"莲花超市");
        Thread busi2=new Thread(new BusiThread(storage),"果果香水果店");
        Thread farmer=new Thread(new FarmerThread(storage),"果农老王");
        farmer.start();
        busi1.start();
        busi2.start();
    }
}

在以上代码中，变量count存储现有仓库库存；get()方法实现当仓库库存大于零时，对外向果商或商超发货，每次发货一车；put()方法实现当仓库库存为零时，由果园的果农向仓库供货，每次供货三车。为了展示更多的数据方便观察效果，在示例代码中，FarmerThread类和BusiThread类中存在死循环。

运行结果：

果农老王：已向仓库发送1车水果
果果香水果店：采购了第2车水果
莲花超市：采购了第2车水果
莲花超市：采购了第0车水果
果农老王：已向仓库发送2车水果
莲花超市：采购了第1车水果
果果香水果店：采购了第1车水果
果果香水果店：采购了第0车水果
莲花超市：采购了第0车水果
果农老王：已向仓库发送1车水果
果果香水果店：采购了第2车水果
莲花超市：采购了第2车水果
莲花超市：采购了第1车水果
果果香水果店：采购了第2车水果
果农老王：已向仓库发送1车水果
莲花超市：采购了第3车水果
果果香水果店：采购了第0车水果

从运行结果可以发现，运行结果中存在如下数据问题：

  1. 不是从第一车水果开始供货。
  2. 出现果果香水果店和莲花超市共同采购同一车水果的情况。
  3. 果农老王应该运输三车水果到仓库，但数据显示只发送两车。

多个线程共同操作同一共享资源会带来数据不安全问题。具体原因是在Storage类中存在以下情况：

  1. 存在多个线程共同操作的变量count。
  2. 在get()方法和put()方法中，存在修改数据和显示数据两步操作。

二、如何实现线程同步

当两个或多个线程需要访问同一资源时，需要以某种顺序来确保资源某一时刻只能被一个线程使用，这被称为线程同步。线程同步相当于为线程中需要一次性完成不允许中断的操作加上一把锁，从而解决冲突。

1、同步代码块

代码块即使用“{}”括起来的一段代码，使用synchronized关键字修饰的代码块被称为同步代码块。

语法结构：

synchronized(obj){
	//需要同步的代码
}

示例：

package d10;

public class Storage2 {
    public final int MAX_COUNT = 3;//最大库存三车

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }

    private int count = 0;//库存量

    //对外向果商发货
    public void get() {
        synchronized (this) {
            if (count > 0) {
                count--;//1.修改数据
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                //2.显示数据
                System.out.println(Thread.currentThread().getName() + "：采购了第" + (MAX_COUNT - count) + "车水果");
            }
        }
    }

    //果园向仓库供货
    public void put() {
        synchronized (this) {
            if (count == 0) {
                count = MAX_COUNT;//1.修改数据
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println(Thread.currentThread().getName() + "：已向仓库发送" + count + "车水果");//显示数据
            }
        }
    }
}

class BusiThread2 implements Runnable {
    Storage2 storage;

    public BusiThread2(Storage2 storage) {
        this.storage = storage;
    }

    public void run() {
        while (true) {
            this.storage.get();//仓库供应一车水果
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

class FarmerThread2 implements Runnable {
    Storage2 storage;

    public FarmerThread2(Storage2 storage) {
        this.storage = storage;
    }

    public void run() {
        while (true) {
            this.storage.put();//向仓库运送一车水果
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

class Test8 {
    public static void main(String[] args) {
        Storage2 storage = new Storage2();//创建仓库类对象
        Thread busi1 = new Thread(new BusiThread2(storage), "莲花超市");
        Thread busi2 = new Thread(new BusiThread2(storage), "果果香水果店");
        Thread farmer = new Thread(new FarmerThread2(storage), "果农老王");
        farmer.start();
        busi1.start();
        busi2.start();
    }
}

运行结果：

果农老王：已向仓库发送3车水果
果果香水果店：采购了第1车水果
莲花超市：采购了第2车水果
果果香水果店：采购了第3车水果
果农老王：已向仓库发送3车水果
果果香水果店：采购了第1车水果
莲花超市：采购了第2车水果
果果香水果店：采购了第3车水果
果农老王：已向仓库发送3车水果
果果香水果店：采购了第1车水果
莲花超市：采购了第2车水果
果果香水果店：采购了第3车水果
果农老王：已向仓库发送3车水果
果果香水果店：采购了第1车水果
莲花超市：采购了第2车水果
果果香水果店：采购了第3车水果
果农老王：已向仓库发送3车水果
果果香水果店：采购了第1车水果
莲花超市：采购了第2车水果
果果香水果店：采购了第3车水果

2、同步方法

如果一个方法的所有代码都属于需同步的代码，那么这个方法定义处可以直接使用synchronized关键字修饰，即同步方法。

语法结构：

package d10;

public class Storage3 {
    public final int MAX_COUNT = 3;//最大库存三车

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }

    private int count = 0;//库存量

    //对外向果商发货
    public synchronized void get() {
        if (count > 0) {
            count--;//1.修改数据
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            //2.显示数据
            System.out.println(Thread.currentThread().getName() + "：采购了第" + (MAX_COUNT - count) + "车水果");
        }
    }

    //果园向仓库供货
    public synchronized void put() {
        if (count == 0) {
            count = MAX_COUNT;//1.修改数据
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println(Thread.currentThread().getName() + "：已向仓库发送" + count + "车水果");//显示数据
        }
    }
}

class BusiThread3 implements Runnable {
    Storage3 storage;

    public BusiThread3(Storage3 storage) {
        this.storage = storage;
    }

    public void run() {
        while (true) {
            this.storage.get();//仓库供应一车水果
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

class FarmerThread3 implements Runnable {
    Storage3 storage;

    public FarmerThread3(Storage3 storage) {
        this.storage = storage;
    }
    public void run(){
        while (true) {
            this.storage.put();//向仓库运送一车水果
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}
class Test9{
    public static void main(String[] args) {
        Storage3 storage=new Storage3();//创建仓库类对象
        Thread busi1=new Thread(new BusiThread3(storage),"莲花超市");
        Thread busi2=new Thread(new BusiThread3(storage),"果果香水果店");
        Thread farmer=new Thread(new FarmerThread3(storage),"果农老王");
        farmer.start();
        busi1.start();
        busi2.start();
    }
}

运行结果：

果农老王：已向仓库发送3车水果
果果香水果店：采购了第1车水果
莲花超市：采购了第2车水果
果果香水果店：采购了第3车水果
果农老王：已向仓库发送3车水果
果果香水果店：采购了第1车水果
莲花超市：采购了第2车水果
果果香水果店：采购了第3车水果
果农老王：已向仓库发送3车水果
果果香水果店：采购了第1车水果
莲花超市：采购了第2车水果
果果香水果店：采购了第3车水果
果农老王：已向仓库发送3车水果
果果香水果店：采购了第1车水果
莲花超市：采购了第2车水果
果果香水果店：采购了第3车水果
果农老王：已向仓库发送3车水果
果果香水果店：采购了第1车水果
莲花超市：采购了第2车水果
果果香水果店：采购了第3车水果
果农老王：已向仓库发送3车水果
果果香水果店：采购了第1车水果
莲花超市：采购了第2车水果
果果香水果店：采购了第3车水果

3、线程同步特征

所谓线程之间保持同步，是指不同的线程在执行之间以同一个对象作为锁标记的同步代码块或同步方法时，因为要获得这个对象的锁而相互牵制，线程同步具有以下特征：

  1. 当多个并发线程访问同一对象的同步代码块或同步方法时，同一时刻只能有一个线程运行，其他线程必须等待当前线程运行完毕后才能运行。
  2. 如果多个线程访问的不是同一共享资源，则无需同步。
  3. 当一个线程访问Object对象的同步代码块或同步方法时，其他线程仍可以访问该Object对象的非同步代码块及非同步方法。
    综上所述，synchronized关键字就是为当前的代码块声明一把锁，获得这把锁的线程可以执行代码块里的指令，其他线程只能等待取锁，然后才能执行相同的操作。

三、线程安全的类型

若程序所在的进程中有多个线程，而当这些线程同时运行时，每次的运行结果和单线程的运行结果是一样的，而且其他变量的值夜和预期相同，那么当前程序就是线程安全的。
一个类在被读线程访问时，不管运行时对这些线程有怎样的时序安排，它必须是以固定的、一致的顺序执行，这样的类型被称为线程安全的类型。

1、ArrayList是常用的集合类型，它是否线程安全的呢？

答案是ArrayList是非线程安全的类型。
而ArrayList集合添加一个元素主要完成如下两步操作：

  1. 判断列表容量是否足够，是否需要扩容。
  2. 将元素添加到列表的元素数组里。
    以上两步操作并非不可分割，这样也就出现了导致线程不安全的隐患。在多个线程执行add()方法进行添加元素操作时，可能会导致elementData数组越界。

2、对比 Hashtable和HashMap

1、是否线程安全

Hashtable是线程安全的，其方法时同步的，可查看Hashtable类型源码中操作数据的方法为同步方法。
而HashMap中的方法在默认情况下是非同步的。在多线程并发的环境下，可以直接使用Hashtable。
如果使用HashMap，就要自行增加同步处理。

2、效率比较

由于Hashtable是线程安全的，其方法是同步的，而HashMap是非线程安全的，重速度，轻安全，所以当只需要单线程时，使用HashMap的执行速度要搞过Hashtable。

3、对比StringBuffer和StringBuilder

StringBuffer和StringBuilder都可用来存储字符串变量，是可变的对象。它们的区别是StringBuffer是线程安全的，而StringBuilder是非线程安全的。因此，在单线程环境下StringBuilder执行效率更高。

四、线程的状态转换

线程的状态转换就是利用了Thread常用方法，
在Java语言使用Thread类及其子类的对象表示线程，新建的线程通常会在五钟状态中转换，即新建（New）、就绪（Runnable）、运行（Running）、阻塞（Blocked）和死亡。
这里就不多讲了！！！

总结

多线程允许程序员编写出可最大程度利用CPU的高效程序。

  1. 在Java程序启动时，一个线程立刻运行，该线程通常被成我饿程序的主线程。主线程是产生其他子线程的线程。
  2. 通常，主线程必须最后完成运行，因为它执行各种关闭动作。

可通过两种方式创建线程。

  1. 声明一个继承了Thread类的子类，在此子类中，重写Thread类的run()方法。
  2. 声明一个实现Runnable接口的类，然后实现run()方法。

每一个线程均会处于新建、就绪、运行、阻塞、死亡五钟状态之一。
在Java实现的多线程应用程序中，可以通过调用Thread类中的方法实现对线程类对象的操作。

  1. 调整线程的优先级：在同等情况下，优先级高的线程会获得较多的运行机会，优先级低的线程则相反。Java线程优先级用1~10的整数表示。
  2. 线程休眠：sleep(long millis)方法使线程转到阻塞状态。
  3. 线程的强制运行：join()方法可以让某一线程强制运行。
  4. 线程礼让：yield()方法，暂停当前正在执行的线程类对象，把执行机会让给相同或更高优先级的线程。

当多个线程类对象操作同一共享资源时，要使用synchronized关键字进行资源的同步处理，可以使用同步代码块或同步方法实现线程同步。

NoloveisGod
关注
  • 57
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java多线程详解——一篇文章搞懂Java多线程
CSDN_KONGlX的博客
05-06 3497
Java多线程详解 1. 基本概念 程序(program) 程序是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码(还没有运行起来)，静态对象。 进程(process) 进程是程序的一次执行过程，也就是说程序运行起来了，加载到了内存中，并占用了cpu的资源。这是一个动态的过程：有自身的产生、存在和消亡的过程，这也是进程的生命周期。 进程是系统资源分配的单位，系统...
Java多线程（超详细）
qq_43390466的博客
05-23 2485
多任务处理有两种：基于进程进程是一种"自包容"的运行程序，有操作系统直接管理，直接运行，有自己的地址空间，每一个进程开启都会消耗内存基于进程的特点是允许计算机同时运行多个程序基于线程在一个程序中，能独立运行的程序片段叫做“线程”，线程是进程内部单一的顺序控制流一个进程拥有多个线程。多个线程共享一个进程的内存空间基于线程的多任务处理环境中，线程是最小的处理单位。
Java多线程实战-从零手搓一个简易线程池(二)线程池实现与拒绝策略接口定义
热门推荐
qq_35716689的博客
03-27 14万+
在前面的文章中，我们讲解了任务堵塞队列的实现，这篇文章会基于任务堵塞队列实现一个简易的线程池，在后续的文章中，还会继续对本章编写的线程池进行功能扩展和优化。
【Java多线程进阶】线程池详解
我的主页
05-31 3605
本文讲解：Java 如何创建线程池，以及线程池底层的类，线程池的四个拒绝策略，模拟实现线程池。
Java多线程（超详细！）
m0_74823507的博客
10-10 316
进程是:一个应用程序（1个进程是一个软件）。线程是：一个进程中的执行场景/执行单元。一个进程可以启动多个线程。eg.对于java程序来说，当在DOS命令窗口中输入：java HelloWorld 回车之后。会先启动JVM，而JVM就是一个进程。JVM再启动一个主线程调用main方法（main方法就是主线程同时再启动一个垃圾回收线程负责看护，回收垃圾。最起码，现在的java程序中至少有两个线程并发，一个是 垃圾回收线程，一个是 执行main方法的主线程。t1线程执行t1的。
java多线程基础篇讲解
03-11
Java多线程基础篇讲解是针对初学者设计的教程，旨在用简洁明了的语言帮助学习者更容易理解多线程的概念和应用。多线程编程在现代计算机系统中扮演着重要角色，尤其在CPU主频发展遇到瓶颈的情况下，通过超线程技术和...
Java多线程编程实战指南 设计模式篇
07-26
《Java多线程编程实战指南 设计模式篇》是一本深度探讨Java并发编程与设计模式融合的书籍。在Java编程中，多线程是提升系统性能、实现并行计算的关键技术，而设计模式则是解决常见问题的最佳实践。本书旨在帮助...
java 多线程编程实战指南（核心 + 设计模式 完整版）
03-20
《Java多线程编程实战指南》这本书深入浅出地讲解了Java多线程的核心概念和实战技巧，分为核心篇和设计模式篇，旨在帮助开发者掌握并应用多线程技术。 1. **线程基础** - **线程的创建**：Java提供了两种创建线程...
Java多线程编程实战指南核新篇&设计篇&以及和核新篇的案例代码
05-30
核心篇主要讲解了Java多线程的基础概念，包括线程的创建与启动、线程同步机制如synchronized关键字、wait()、notify()和notifyAll()方法、线程间通信的并发工具类如Semaphore、CyclicBarrier、CountDownLatch等。...
多线程编程实战指南-核心篇
07-16
总之，《多线程编程实战指南-核心篇》是一本全面解析Java多线程编程的书籍，通过学习，开发者不仅可以掌握多线程编程的基本原理，还能学会如何在实际项目中应用这些知识，提升程序的并发性能和稳定性。对于有一定...
Java-Lambda
最新发布
lizhiwei21的博客
07-21 332
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 568
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
接口防刷！利用redisson快速实现自定义限流注解
架构师小吴的博客
07-18 1186
如登录接口，当用户使用手机号+验证码登录时，一般我们会生成6位数的随机验证码，并将验证码有效期设置为1-3分钟，如果对登录接口不加以限制，理论上，通过技术手段，快速重试100000次，即可将验证码穷举出来。解决思路：对登录接口加上限流操作，如限制一分钟内最多登录5次，登录次数过多，就返回失败提示，或者将账号锁定一段时间。在日常开发中，一些重要的对外接口，需要加上访问频率限制，以免造成资��损失。ok，通过以上两步，即可完成我们的限流注解了，下面通过一个接口验证下效果。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 1172
JVM-垃圾回收与内存分配
【Java算法】前缀和 下
2302_79806056的博客
07-18 1077
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
华为OD机试 - 分披萨 - 递归（Java 2024 D卷 200分）
学Java，找哪吒
07-21 741
递归算法通过函数调用自身解决问题，每次递归调用都处理问题的一个子部分，直到达到基准条件，从而构建最终解。
【Java并发编程之美 | 第三篇】Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
踢桃的成长之路
07-21 652
Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
对androidTestDebug 产物进行重新签名
shuizhizhiyin的专栏
07-19 511
在运行 gradle assembleAndroidTestDebug 任务后，自定义的 reSignAndroidTestDebug 任务将会被执行，并对子模块的 androidTestDebug 产物进行重新签名。your_keystore_path.jks、your_keystore_password、your_key_alias 和 your_key_password 需要替换为你的实际路径和密码。如果需要对其他子模块的产物进行重新签名，可以根据需要创建不同的自定义任务。// 设置密钥库密码。
每 日练 习
m0_67187271的博客
07-19 1030
正确答案：C 解析：是正确的，这是最基本的类定义形式，没有继承任何类，也没有实现任何接口。也是正确的，这里定义了一个名为x的类，它继承了名为y的类。同样是正确的，这里定义了一个公共类x，它继承了Applet类，这在Java中是合法的，尤其是在创建GUI应用程序时常见。是不正确的，因为在Java中，我们不能使用static关键字来修饰一个类的定义。static关键字只能用于类的方法、变量或者是内部类（即嵌套类），但不能用于顶级类（非嵌套类）。所以，这个选项是错误的。因此，正确答案是C。
Java多线程入门：原理、模型与实践
Java并发性和多线程教程深入讲解了Java语言在并发编程领域的核心概念和实践技巧。作为Java开发中的重要知识点，本文档旨在帮助初级工程师理解并掌握多线程的基本原理、优点、代价以及并发编程模型的选择。 首先，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值