Java并发与同步(上)

最新推荐文章于 2021-07-28 20:01:13 发布
最新推荐文章于 2021-07-28 20:01:13 发布
阅读量295 收藏
点赞数
分类专栏： Java基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42254247/article/details/102632328
版权

并发

本文档建立在之前博客基础上。

  1. 直接调用Thread类或Runnable对象的run()方法，只会执行统一线程中的任务，而不会启动新线程。调用start()方法，此方法将创建一个执行run方法的新线程。
中断线程

  1. 调用interrupt()方法，可以请求终止线程。调用Thread.currentThread()得到当前线程，再使用isInterrupt()来判断线程是否被终止。

  2. 若线程被阻塞（调用sleep或wait），则无法检测中断状态。

    • void interrupt()
向线程发送中断请求。线程的中断状态将被设置为true。如果目前该线程被一个sleep调用阻塞，那么，InterruptedException 异常被抛出。
• static boolean interrupted()
测试当前线程（即正在执行这一命令的线程）是否被中断。注意，这是一个静态方法。这一调用会产生副作用—它将当前线程的中断状态重置为 false。
• boolean islnterrupted()
测试线程是否被终止。不像静态的中断方法，这一调用不改变线程的中断状态。
• static Thread currentThread()
返回代表当前执行线程的 Thread 对象。
线程状态
  1. 线程可以有如下 6 种状态：

  • New (新创建）

  • Runnable (可运行）

  • Blocked (被阻塞）

  • Waiting (等待）

  • Timed waiting (计时等待）

  • Terminated (被终止）

  1. 要确定一个线程的当前状态，调用getState()方法。
抢占式调度和协作式调度
  1. 抢占式调度系 统给每一个可运行线程一个时间片来执行任务。当时间片用完，操作系统剥夺该线程的运行 权， 并给另一个线程运行机会当选择下一个线程时， 操作系统考虑线程的优先级。 现在所有的桌面以及服务器操作系统都使用抢占式调度 。
  2. 像手机这样的小型设备 可能使用协作式调度。在这样的设备中，一个线程只有在调用 yield 方法、 或者被阻塞或等 待时，线程才失去控制权。

在任何给定时刻，一个可运行的线程可能正在运行也可能没有运行（这就是为什 么将这个状态称为可运行而不是运行

被阻塞线程和等待线程
  1. 当线程处于被阻塞或等待状态时，它暂时不活动。它不运行任何代码且消耗最少的资源。直到线程调度器重新激活它。细节取决于它是怎样达到非活动状态的。

在这里插入图片描述

线程属性

线程优先级、守护线程、 线程组以及处理未捕 获异常的处理器。

  1. 线程优先级

    1. 在 Java 程序设计语言中，每一个线程有一个优先级。默认情况下， 线程继承它的父 线程的优先级。可以用setPriority方法提高或降低任何一个线程的优先级。
    2. 每当线程调度器有机会选择新线程时， 它首先选择具有较高优先级的线程。但是，线程 优先级是高度依赖于系统的。
    3. 不要将程序构建 为功能的正确性依赖于优先级。

  2. 守护线程

    1. 可以通过调用 t.setDaemon(true); 将线程转换为守护线程。 这一方法必须在线程启动之前调用。 守护线程的唯一用途 是为其他线程提供服务。 当只剩下守护线程时， 虚拟机就退出了 。
    2. 守护线程应该永远不去访问固有资源， 如文件、 数据库，因为它会在任何时 候甚至在一个操作的中间发生中断。

  3. 未捕获异常处理器

    1. 线程的 run方法不能抛出任何受查异常（必须在内部使用try...catch来解决发生的任何必须处理异常）， 但是，非受査异常（典型代表：RuntimeException）会导致线程终止。在这种情 况下，线程就死亡了。

    2. 在线程死亡之前， 异常被传递到一个用于未捕获异常的处理器。 该处理器必须属于一个实现 Thread.UncaughtExceptionHandler接口的类。这个接口只有一个方法：

      void uncaughtException(Thread t, Throwable e)

    3. 可以用 setUncaughtExceptionHandler方法为任何线程安装一个处理器。也可以用 Thread 类的静态方法 setDefaultUncaughtExceptionHandler为所有线程安装一个默认的处理器。

    4. 如果不安装默认的处理器， 默认的处理器为空。但是， 如果不为独立的线程安装处理 器，此时的处理器就是该线程的 ThreadGroup对象。

      Thread aThread = new Thread(() -> {
    System.out.println("执行开始");
    int a = 10 / 0;
    System.out.println("执行结束");
}, "A");
aThread.start();

// 默认线程组处理结果
/*
执行开始
Exception in thread "A" java.lang.ArithmeticException: / by zero
	at BaseLearn.multithreadingTest.Test6.Main.lambda$main$0(Main.java:11)
	at java.lang.Thread.run(Thread.java:748)
*/

Thread aThread = new Thread(() -> {
    System.out.println("执行开始");
    int a = 10 / 0;
    System.out.println("执行结束");
}, "A");
aThread.setUncaughtExceptionHandler((Thread t, Throwable e) -> {
    System.out.println("发现错误了");
    System.out.println(e.toString());
});
aThread.start();

// 添加自定义异常处理
Thread aThread = new Thread(() -> {
    System.out.println("执行开始");
    int a = 10 / 0;
    System.out.println("执行结束");
}, "A");
aThread.setUncaughtExceptionHandler((Thread t, Throwable e) -> {
    System.out.println("发现错误了");
    e.printStackTrace();
});
aThread.start();

/*
执行开始
java.lang.ArithmeticException: / by zero
发现错误了
	at BaseLearn.multithreadingTest.Test6.Main.lambda$main$0(Main.java:11)
	at java.lang.Thread.run(Thread.java:748)
*/

    5. 线程组是一个可以统一管理的线程集合。默认情况下，创建的所有线程属于相同的线程组， 但是， 也可能会建立其他的组。现在引入了更好的特性用于线程集合的操作， 所以建议不要在自己的程序中使用线程组。

同步

  1. 在大多数实际的多线程应用中， 两个或两个以上的线程需要共享对同一数据的存取。若线程调用了一个修改该对象状态的方法，根据各线程访问数据的次序，可能会产生讹误的对象。这样一个情况通常称为竞争条件。

    竞争条件例子：（示例来自Java核心技术卷14.5.1，643页）

    模拟一个有若干账户的银行。随机地生成在这些账户之间转移钱 款的交易。每一个账户有一个线程。每一笔交易中， 会从线程所服务的账户中随机转移一定 数目的钱款到另一个随机账户。

    // 第一部分截取
public void transfer(int from, int to, double amount { 
    System.out.print(Thread,currentThread0);
    // 从accounts的第from账户中扣钱
    accounts[from] -= amount; 
    System.out.printff" X10.2f from Xd to Xd", amount, from, to); 
    // 加给to账户
    accounts[to] += amount; 
    System.out.printf("Total Balance: X10.2fXn", getTotalBalance())； 
} 
   
// 第二部分截取
Runnable r = () -> {
    try { 
        while (true) { 
            // 转义账户随机生成
            int toAccount = (int) (bank.sizeO * Math.random()); 
            // 转义钱数
            double amount = MAX_AMOUNT * Math.random();
            // 转移
            bank.transfer(fromAccount, toAccount, amount); 
            // 暂停一会
            Thread,sleep((int) (DELAY * Math.randomO)); 
        } 
    } catch (InterruptedExeeption e){
        
    }
} ；

    示例程序源代码存放在个人码云示例中点击访问

    执行结果：

    Thread[Thread-26,5,main]      82.57 from 26 to 35 Total Balance:  100000.00
Thread[Thread-44,5,main]     819.26 from 44 to 49 Total Balance:  100000.00
Thread[Thread-37,5,main]     966.78 from 37 to 40 Total Balance:  100000.00
Thread[Thread-5,5,main]     811.87 from 5 to 89 Total Balance:  100000.00
Thread[Thread-81,5,main]     344.01 from 81 to 3 Total Balance:  100000.00
Thread[Thread-14,5,main]     730.87 from 14 to 17 Total Balance:  100000.00
Thread[Thread-87,5,main]     965.71 from 87 to 97 Total Balance:  100000.00
Thread[Thread-6,5,main]Thread[Thread-62,5,main]Thread[Thread-39,5,main]     313.93 from 39 to 56 Total Balance:   99331.28
Thread[Thread-57,5,main]      31.16 from 57 to 36 Total Balance:   99331.28
Thread[Thread-77,5,main]Thread[Thread-57,5,main]     523.69 from 57 to 19 Total Balance:   98750.24
Thread[Thread-17,5,main]     537.68 from 17 to 22 Total Balance:   98750.24
     581.04 from 77 to 13 Total Balance:   99331.28
Thread[Thread-13,5,main]     212.00 from 13 to 46 Total Balance:   99331.28
Thread[Thread-91,5,main]      98.60 from 91 to 34 Total Balance:   99331.28
Thread[Thread-20,5,main]     898.50 from 20 to 95 Total Balance:   99331.28
      15.54 from 62 to 70 Total Balance:   99346.82
     653.18 from 6 to 34 Total Balance:  100000.00
Thread[Thread-20,5,main]     777.97 from 20 to 14 Total Balance:  100000.00
Thread[Thread-13,5,main]     194.07 from 13 to 40 Total Balance:  100000.00
Thread[Thread-74,5,main]     815.60 from 74 to 58 Total Balance:  100000.00
Thread[Thread-70,5,main]     844.52 from 70 to 73 Total Balance:  100000.00

    由结果可以看出。一段时间之后， 错误不知不觉地出现了，总额要么增加， 要么变少。当两个线程试图同时更新同一个账户的时候， 这个问题就出现了。

    1. 个人分析：因为线程执行时有抢占资源的问题，假定现在Thread-1线程为A向B转钱，A账户钱数减少时，Thread-2线程此时抢占到了资源开始运行，此时A的钱数少了，所以银行总钱数减少，但是后续线程A又拿到了运行权，此时才会继续执行下面的增加B账户钱数的运算。所以后面钱数又回归正常了。

    2. 官方分析：假定两个线程同时执行指令

      accounts[to] += amount;

      问题在于这不是原子操作。该指令可能被处理如下：

      1. 将 accounts[to] 加载到寄存器。
      2. 增加 amount。
      3. 将结果写回 accounts[to]。

      现在，假定第 1 个线程执行步骤 1 和 2, 然后， 它被剥夺了运行权。假定第 2 个线程被 唤醒并修改了 accounts 数组中的同一项。然后，第 1 个线程被唤醒并完成其第 3 步。 这样， 这一动作擦去了第二个线程所做的更新。于是， 总金额不再正确。（见图 14-4J 我们的测试程序检测到这一i化误。（当然， 如果线程在运行这一测试时被中断，也有可能 会出现失败警告！）

    锁对象

    1. 有两种机制防止代码块受并发访问的干扰。Java语言提供一个 synchronized关键字达 到这一目的，并且 Java SE 5.0引入了 ReentrantLock 类。synchronized 关键字自动提供一个 锁以及相关的“ 条件”， 对于大多数需要显式锁的情况， 这是很便利的。

    2. 用 ReentrantLock 保护代码块的基本结构如下：

       myLock.lock(); 
   try { 
       critical section 
   } finally { 
       myLock.unlockO;
   }

    1. 这一结构确保任何时刻只有一个线程进人临界区。一旦一个线程封锁了锁对象， 其他任 何线程都无法通过 lock语句。当其他线程调用 lock 时，它们被阻塞，直到第一个线程释放 锁对象。

    2. 把解锁操作括在 finally 子句之内是至关重要的。如果在临界区的代码抛出异常， 锁必须被释放。否则， 其他线程将永远阻塞。

    3. 如果使用锁， 就不能使用带资源的 try语句。

    修改示例：

    public class Bank { 
    private Lock bankLock = new ReentrantLock0；
    public void transfer(int from, int to, int amount) t bankLock.lock(); 
    try { 
    System.out.print(Thread.currentThread0);     accounts[from] -= amount;     				System.out.printf(" X10.2f from %A to Xd", amount, from, to); 
    accounts[to] += amount; 					System.out.printf(" Total Balance: X10.2fXn", getTotalBalanceO)；
    } finally {
        banklock.unlock();
    }
}

    结果：

    101.10 from 93 to 68 Total Balance:  100000.00
Thread[Thread-66,5,main]      20.39 from 66 to 41 Total Balance:  100000.00
Thread[Thread-5,5,main]     905.92 from 5 to 89 Total Balance:  100000.00
Thread[Thread-87,5,main]     608.07 from 87 to 41 Total Balance:  100000.00
Thread[Thread-38,5,main]     942.93 from 38 to 84 Total Balance:  100000.00
Thread[Thread-39,5,main]     757.74 from 39 to 32 Total Balance:  100000.00
Thread[Thread-62,5,main]     503.86 from 62 to 16 Total Balance:  100000.00
Thread[Thread-4,5,main]     417.09 from 4 to 51 Total Balance:  100000.00
Thread[Thread-67,5,main]     781.40 from 67 to 67 Total Balance:  100000.00
Thread[Thread-56,5,main]     972.45 from 56 to 74 Total Balance:  100000.00
Thread[Thread-91,5,main]     102.22 from 91 to 65 Total Balance:  100000.00
Thread[Thread-58,5,main]     112.92 from 58 to 51 Total Balance:  100000.00
Thread[Thread-61,5,main]     375.14 from 61 to 64 Total Balance:  100000.00
Thread[Thread-1,5,main]     275.49 from 1 to 40 Total Balance:  100000.00
Thread[Thread-33,5,main]     368.64 from 33 to 53 Total Balance:  100000.00
Thread[Thread-25,5,main]     875.35 from 25 to 86 Total Balance:  100000.00
Thread[Thread-30,5,main]     104.90 from 30 to 21 Total Balance:  100000.00
青w韵
关注
专栏目录
并发：同步
YJingLee's CSDN Blog
10-28 372
同步概况 同步是并发最后一个环节。 当两个并发单元共享同一个数据的时候需要同步处理。这里的并发单元不限于进程中的两个线程，也可能两个进程，甚至两台服务器。同步处理不局限共享同一块内存，当两个进程共享同一个文件给文件加锁都是同步处理，在数据库中启动一个事务或者启动乐观锁都是同步处理。共享同一资源产生数据竞争都需要做同步处理。 标准库 sync 包专门用来做同步的，它由条件、锁，锁分为互斥和读写，Wa...
Java并发（一）
代码改变世界
04-22 581
概述：本文主要讲述Java并发中的常见问题，内容涵盖多线程的实现、线程安全、线程安全集合类、线程阀、线程池等内容。第一部分 分布式计算、并行计算、并发计算1.1 并行计算与分布式计算 级别上。并行计算借助于并行算法与并行编程语言，实现进程级并行和线程级并行；分布式计算将任务分成小块分配到各个计算机上执行，属于计算机之间的并行。 粒度上。并行计算中，处理器之间交互频繁，粒度细；分布式计算中，处理器之间
Java并发与同步
weixin_33878457的博客
06-16 80
Java中并发的形式无非是多线程和多进程两种形式。这两种形式都是能够利用多核来发挥计算能力的。 先说并发： 多进程意味着同一时候执行多个JVM。这个代价通常比多线程高，每一个JVM都有自己的堆栈、都要分别载入各自的类。可是多进程的优点是“隔离性”更好，一个JVM中的程序在执行时发生问题不会对其它JVM产生非常大的影响。而在多线程的情况下，一些致命错误可能导致整个JVM挂掉，祸及全体。多...
java-并发和同步
ssehs的博客
05-02 488
前言 一般来说，函数式编程本身就是线程安全的。因为函数式编程的数据结构都是不可变的，数据在各自的线程空间存储和计算，不存在多线程共享（读取和修改）数据的情况。谈到线程安全，一般指的是面对对象的类。 线程安全类 当多个线程访问一个类时，如果不用考虑这些线程在运行时环境下的调度和交替执行，并且不需要额外的同步及在调用方代码不必作其他的协调，这个类的行为仍然是正确的，那么称这个类是线程安全的。 Java...
并发和同步
pcamass的博客
07-28 1555
并发与同步概念 并发 并发：在同一时刻，有多个线程同时访问 某一个（一些）资源，带来数据的不安全性 、不稳定性、不确定性。 生活中例子 下课时，多个同学同时抢占同一坑位。 同步 同步：用于解决并发问题，给予线程权限，允许具有权限的线程执行。 实现同步方法-锁 锁 性质：唯一（static） 使用原则：锁越少越好 ，避免死锁发生 实现方法： 1.synchronized 2.Lock Condition 3.synchronized 方法名() {} ：锁就是当前对象 生活中例子 坑位有锁，需锁开启
Java的并发
hefrankeleyn的博客
02-23 455
Java的并发 文章目录Java的并发一、同步访问共享的可变数据1.1 关键词`synchronized`1.2 同步的概念（1）同步是一种互斥的方式（2）如果没有同步，一个线程的变化就不能被其他线程看到1.3 Java语言规范保证读或者写一个变量是原子的，除非这个变量的类型为long或者double1.4 千万不要使用`Thread.stop`方法1.5 除非读和写操作都被同步，否则无法保证同步...
java并发编程与实践
02-20
"Java并发编程与实践"文档深入剖析了这一主题，旨在帮助开发者理解和掌握如何在Java环境中有效地实现并发。 并发是指在单个执行单元（如CPU）中同时执行两个或更多任务的能力。在Java中，这主要通过线程来实现，...
java并发编程实践pdf笔记
12-15
Java并发编程实践是Java开发中不可或缺的一个领域，它涉及到如何高效、正确地处理多线程环境中的任务。这本书的读书笔记涵盖了多个关键知识点，旨在帮助读者深入理解Java并发编程的核心概念。 1. **线程和进程的...
Java并发：同步容器&并发容器
12-22
Java并发编程中，同步容器和并发容器是两种关键的线程安全数据结构。同步容器，如Vector和Hashtable，是通过内置的`synchronized`关键字来确保线程安全的。这意味着当多个线程尝试访问同步容器的方法时，它们会被...
基于Java并发编程的多线程同步与锁机制.zip
09-06
基于Java并发编程的多线程同步与锁机制 项目简介 本项目旨在深入探讨Java并发编程中的多线程同步与锁机制，涵盖了从基础的线程创建、同步方法到高级的并发工具类如ReentrantLock、ReadWriteLock、Atomic类等的...
java并发编程2
02-15
以上知识点覆盖了Java并发编程的主要方面，包括线程管理、同步机制、并发工具、设计模式、并发集合以及并发编程的最佳实践等，是理解和掌握Java并发编程的关键。在实际开发中，理解和熟练运用这些知识可以编写出高效...
Java同步容器和并发容器
weixin_34212189的博客
04-04 284
同步容器在 Java 中，同步容器主要包括 2 类：Vector、Stack、HashTableVector 实现了 List 接口，Vector 实际上就是一个数组，和 ArrayList 类似，但是 Vector 中的方法都是 synchronized 方法，即进行了同步措施。Stack 也是一个同步容器，它的方法也用 synchronized 进行了同步，它实际上是继承于 Vector 类。...
Java线程并发与同步
weixin_45264992的博客
03-21 428
Java之线程并发 我们知道，多线程存在着数据安全问题。在并发线程中，一个对象同时可以被多个线程访问，修改等。比如购买火车票的例子，若只剩下最后一张火车票，但此时同时有多个线程正在访问该数据，那么如果不加约束，那么这些线程都将成功购得同一张火车票，最后导致系统中火车票剩余数量变为负数！ 以下是一个不加约束的示范： //线程并发即多个线程操作同一个对象 //买火车票的例子 public class TestThread3 implements Runnable{ private int ticket=
并发 - 同步
大漠知秋的加油站
08-23 623
同步锁 全局唯一性操作   之前喊过一句口号，倡导用通信来共享数据，而不是通过共享数据来进行通信，但考虑到即使成功地用 channel 来作为通信手段，还是避免不了多个 goroutine 之间共享数据的问题，Go 语言的设计者虽然对 channel 有极高的期望，但也提供了妥善的资源锁方案。 同步锁   Go 语言包中的 sync 包提供了两种锁类型：sync.Mutex 和 ...
Java并发、同步总结
joye123的博客
09-28 1583
Java中提供并发控制的两种方式：1、同步关键字 2、锁Java 5.0之前使用的是同步关键字Synchronized和volatile，他们是jvm中的隐式锁 Synchronized和volatile的实现是基于jvm指令的同步代码块实现的。 添加同步关键字后，会在jvm代码块指令前后添加monitorexit和monitorenter两个同步指令。 但是Synchronized修饰的方法
Java并发和同步
欢迎交流
01-19 203
使用线程 Java中有三种使用线程的方法： 实现 Runnable 接口； 实现 Callable 接口； 继承 Thread 类。 实现 Runnable 和 Callable 接口的类只能当做一个可以在线程中运行的任务，不是真正意义上的线程，因此最后还需要通过 Thread 来调用。可以理解为任务是通过线程驱动从而执行的。 实现Runnable接口 public class MyRun...
java基于SpringBoot+vue 美食信息推荐系统源码 带毕业论文
最新发布
09-12
1、开发环境：SpringBoot框架；内含Mysql数据库；VUE技术；内含说明文档 2、需要项目部署的可以私信 3、项目代码都经过严格调试，代码没有任何bug！ 4、该资源包括项目的全部源码，下载可以直接使用！ 5、本项目适合作为计算机、数学、电子信息等专业的课程设计、期末大作业和毕设项目，作为参考资料学习借鉴。 6、本资源作为“参考资料”如果需要实现其他功能，需要能看懂代码，并且热爱钻研，自行调试。
Java同步容器与并发容器深度解析
"Java同步容器和并发容器是Java集合框架中的关键部分，它们主要用于多线程环境中的数据存储和管理。同步容器通过内置的锁机制确保了线程安全，但可能带来性能问题；并发容器则提供了更为高效和灵活的线程安全策略。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值