多线程（二）

已于 2023-04-15 08:44:51 修改
阅读量53 收藏
点赞数
文章标签： jvm 面试
于 2023-04-14 14:43:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51050461/article/details/130108075
版权

1、线程的状态

NEW->安排了工作，未开始行动 。

RUNNABLE->可工作的。分为正在工作和即将开始工作。

BLOCKED->排队等着。

TIMED_WAITING->排队等着。

TERMINATED->工作完成。

 18a1dd617f31400083605d837609462e.png

 ->BLOCKED表示等待获取锁

->WAITING和TIMED_WAITING表示等待其他线程发来通知

->TIMED_WAITING线程等待唤醒，但是又时间限制

->WAITING线程在无限等待唤醒

此外：yield(）可以让出CPU， 不改变线程的状态, 但是会重新去排队.

 2、多线程带来的风险----线程安全问题

 理解线程安全问题：如果多线程环境下运行代码的结果是符合预期的，也即与在单线程环境下的结果一致，则说明这个程序是线程安全的。

线程不安全的原因：

（1）抢占式执行

        多个线程的调度执行过程，可视为全随机

（2）多个线程修改共享数据

 举例：count++操作。首先，CPU是以一条指令为单位进行执行。再进行修改操作时，一般有三个CPU指令：1）load:把内存中的数据读取到CPU的寄存器中

                  2）add:把CPU寄存器中的值进行+1操作

                  3）save:把寄存器中的值，写回到内存中

当前，用2个线程修改同一个变量count。每次修改都是3个步骤，不是原子性操作。再由于线程的调度是随机的，所以真正执行这些操作时，有多种排列顺序。比如：

 cfad8626efe84374bf0519a8d0f6296b.png

 

 （3）修改操作不是原子的

         可以从这一原因入手，解决线程不安全问题。

（4）内存可见性问题

 可见性是指，当一个线程对共享变量值的修改，能够及时的被其他线程看到。

Java内存模型：目的是屏蔽掉各种硬件和操作系统的内存访问差异，以实现让Java程序在各种平台下都能达到一致的并发效果.

8bc9e70f208e4649a151a0dbad95e427.png

 ->线程之间的共享变量存在 主内存。

 ->每个线程都有自己的工作内存。

 ->当线程要读取一个共享变量时，会先把变量从主内存拷贝到工作内存，再从工作内存读取数据。

->当线程要修改一个共享变量时，也会先修改工作内存中的副本，再同步回主内存。

 79cb5019bcf244e6954911d6c0a26b65.png

"主内存" 才是真正硬件角度的 "内存". 而所谓的 "工作内存", 则是指 CPU 的寄存器和高速缓存. 

拷来拷去也是因为 CPU 访问自身寄存器的速度以及高速缓存的速度, 远远超过访问内存的速度 。

（5）指令重排序 

        代码重排序，也会引发线程不安全。 

        编译器对指令重排序的前提是”保持逻辑不发生变化“。 多线程代码执行复杂度更高，编译器很难在编译阶段对代码的执行效果进行预测, 因此激进的重排序很容易导致优化后的逻辑和之前不等价.

 3、针对线程不安全问题，怎么解决？

 针对上述count++的例子，

1fc5d21da1f14b0db157b891c8cebc25.png

synchronized关键字

（1）synchronized的特性

 互斥：

 某个线程执行到某个对象的synchronized中时，其他线程如果也执行到同一个对象的synchronized就会阻塞等待。

->进入synchronized修饰的代码块，相当于加锁；退出synchronized修饰的代码块，相当于解锁 。

->阻塞等待： 针对每一把锁，都有一个等待队列。当这个锁被某个线程占有的时候，其他线程尝试进行加锁，就加不上。就得阻塞等待，知道之前的线程解锁后，操作系统会唤醒一个新的线程，再来获取到这个锁。

 刷新内存【不一定】：

 synchronized 的工作过程: 获得互斥锁->从主内存拷贝变量到工作内存->执行变量的相关操作->将更改后的共享变量的值刷新到主内存->释放锁。

 所以 synchronized 也能保证内存可见性.

 可重入：

synchronized同步块对同一条线程来说是可重入的，不会出现自己把自己锁死的问题。 

自己把自己锁死的问题 ：自己加锁，但忘了解锁；二次加锁时，无法操作==》死锁。【这里只是死锁出现的一种形态，还会有其他形态。】

 synchronized是可重入的。

        -》可重入锁的底层实现：让锁里面记录好，是哪个线程持有的这把锁即可。

        -》可重入锁进行解锁：引入一个计数器。每次加锁，计数器++；解锁，计数器--。如果计数器为0，此时的加锁才是真加锁；同样的，计数器为0，此时的解锁才是真解锁。 

（2）synchronized的用法

 修饰方法：

31d00c193efa4a0691951b4b0176549b.png

 修饰代码块：

把要加锁的逻辑方法到synchronized修饰的代码块中，也能起到加锁的作用。

f0e8977a77164969ad338f9fc7a4e3ce.png

->在java中，任意的对象都可以进行加锁。例如下面：

3e8701a8013643eb9b81e14b303b782d.png 

->在写多线程代码时，不关心这个锁对象是什么。只需关心两个线程是否锁同一个对象；如果是，就会产生锁竞争 ，锁不同对象，就无锁竞争。

 锁对象只是用来控制线程之间的互斥的。

->针对不同对象加锁，就不会出现锁竞争。

->下面这两种写法都是线程安全的。

写法1：

e82af717a6f940a9b9f6050e7fa3a8c5.png

写法2 、3：

85c91bb1b7a648729596f05c070009ce.png

 ->写法4：

1dd2eb10e8e44b5588c0bd7c624322e4.png

 ->写法5:

类对象在JVM中只有一个 。

61fc60622716467eba6ba7a1871dffd7.png

 锁对象的核心原则：两个线程竞争同一个锁对象，就有竞争；不同的锁对象，就没有竞争。

锁竞争的目的：保证线程安全。 

 （3）总结一下synchronize：

synchronize的几种写法：

->修饰普通方法：锁对象相当于this

->修饰代码块：锁对象在（）中指定

->修饰静态方法：锁对象相当于类对象。

 

 

嘿呦秀儿
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【多线程】（基础二）
haoshaokang_的博客
08-18 810
线程安全问题：在操作系统的随机调度下 ，多个线程的并发执行会产生多种可能，可能会产生BUG 我们使用两个线程对同一个变量分别自增了5000次，按理来说最后结果应该是10000，下面我们来看结果 a++; 这一行代码对应了三条机器指令：从内存读取数据到CPU（load），在CPU寄存器中完成加法运算（add），把运算结果放到内存中（save）那由于两个线程的执行是调度器随机调度的，所以在某一时刻，这两个线程可能都在CPU的不同核心上运行（并行执行），也可能只有一个在CPU上执行，也可能俩线程都没在CPU上
Linux 多线程原理深剖
qq_61500888的博客
12-24 3万+
带你一命通关 Linux 多线程原理 三十分钟手撕底层内涵
java进阶(七)------多线程---多线程操作同一变量
直到世界的尽头
07-02 1万+
情况首先要肯定的是ThreadLocal和局部变量是线程安全的，静态和实例变量都是不安全的。我们常常在系统中会用一些 静态变量 作为 共同的状态标记。但在多线程中常常发现这个 变量的增减 会出现错乱  并不是预期中的结果显示。例如:package test.autorun; public class ShareVar { private static int nCount=0; pub
【并发编程】多线程读写同一变量的并发问题（并发编程启动）
小明的Java问道之路
10-23 1449
通过下单链路扣减库存引出了多线程并发访问共享变量的问题，接着简单介绍了一下计算机CPU内存模型、Java的内存模型，并基于Java的内存模型一步一图分析线程安全问题产生的原因。
多线程操作同一个变量
gddghs
12-28 1万+
在java线程并发处理中，有一个关键字volatile的使用目前存在很大的混淆，以为使用这个关键字，在进行多线程并发处理的时候就可以万事大吉。 Java语言是支持多线程的，为了解决线程并发的问题，在语言内部引入了 同步块 和 volatile 关键字机制。 synchronized  同步块大家都比较熟悉，通过 synchronized 关键字来实现，所有加上synchronized
多线程
qq_32138221的博客
03-28 169
本文主要介绍下java多线中常用的关键字和对象。 1.volatitle：保证了线程之间变量的可见性，但是并不具有原子性。 所谓可变性，就是每个线程读取到的值都是最新的，即使某个线程改变了变量的值，其他的线程也能马上看到修改后的值。 所谓原子性，即一个操作或者多个操作 要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。 那么为什么这个关键字就能保证了可变性，又为什么不能保证原子
Java多线程超详解
热门推荐
weixin_44797490的博客
06-11 14万+
引言 随着计算机的配置越来越高，我们需要将进程进一步优化，细分为线程，充分提高图形化界面的多线程的开发。这就要求对线程的掌握很彻底。 那么话不多说，今天本帅将记录自己线程的学习。 线程的相关API //获取当前线程的名字 Thread.currentThread().getName() 1.start():1.启动当前线程2.调用线程中的run方法 2.run():通常需要重写Thread类中的此...
C#高级--多线程详解
李宥的博客
10-03 4万+
C#高级–多线程详解 零、文章目录 一、什么是多线程 1、进程 当一个程序开始运行时，它就是一个进程，进程包括运行中的程序和程序所使用到的内存和系统资源。 而一个进程又是由多个线程所组成的。 2、线程 线程是程序中的一个执行流，每个线程都有自己的专有寄存器(栈指针、程序计数器等)，但代码区是共享的，即不同的线程可以执行同样的函数。 3、句柄 句柄是Windows系统中对象或实例的标识，这些对象包括模块、应用程序实例、窗口、控制、位图、GDI对象、资源、文件等。 4、多线程 （1）多线程概念 多线程是指程序中
C++多线程详细讲解
qq_45439571的博客
03-19 4万+
本文是纯转载，觉得大佬写的非常好！如有侵权可以删除 链接: link. C++多线程基础教程 目录 1 什么是C++多线程？ 2 C++多线程基础知识 2.1 创建线程 2.2 互斥量使用 lock()与unlock(): lock_guard(): unique_lock: condition_variable: 2.3 异步线程 async与future： shared_future 2.4 原子类型automic 实例 生产者消费者问题 4 C++多线程高级知识 4.1 线程池 线程池基础知识 线程池
多线程 hbase
03-03
二、多线程与HBase 1. **批量操作**：在HBase中，多线程可以用于批量写入和读取操作。例如，通过使用HBase的`TableOutputFormat`和MapReduce的多线程模型，可以将大量数据并行写入表中，显著提高写入效率。同时，...
WPF多线程实例
05-08
在Windows Presentation Foundation（WPF）开发中，多线程是一个重要的技术，特别是在处理大量数据或进行耗时操作时，为了保持用户界面（UI）的响应性，通常会使用多线程来实现非UI任务。本实例是关于如何在WPF应用...
多线程Demo
11-27
二、多线程的实现 1. **继承Thread类**：在Java中，我们可以创建一个新的类，继承自`Thread`类，重写`run()`方法，然后创建该类的实例并调用`start()`方法启动线程。 2. **实现Runnable接口**：另一种方式是创建一...
认识多线程
01-06
认识多线程 多任务： 类似于生活中的一心二用，同时吃饭玩手机，或者边听歌边写作业 多线程： 类似于生活中的马路，为了提高使用的效率，多加了几条车道 普通方法调用和多线程 Process和Thread 程序是指令和数据的...
面试题005-Java-JVM(上)
zouhuu的博客
07-05 1118
1. JVM由哪几部分组成？ 2. 运行时数据区中包含哪些区域？ 3. 栈和堆中分别存放什么数据？ 4. 为什么要将永久代 (PermGen) 替换为元空间 (MetaSpace) ？ 5. 堆空间的基本结构了解吗？什么情况下对象会进入老年代？ 6. 大对象放在哪个内存区域？ 7. Java对象的创建过程？
科普文：一文搞懂jvm实战(二)Cleaner回收jvm资源
为无为，事无事，味无味。
07-02 1073
finalize()方法实际上从JDK1.0时就开始提供，但一直到JDK1.9后才发现此方法成为了不推荐使用的方法，同时这个方法上所抛出的一个Throwabke类型的异常（Erroe和Exception），在对象回收时可能会出现各种问题，但不影响回收！System.out.println("诞生！");@Overrideprotected void finalize() throws Throwable { //可能抛错误，也可能抛异常System.out.println("回收！");
C++ 学习笔记一
m0_51830537的博客
07-03 814
由于在 C++ 中输入或显示指数可能很困难，我们使用字母“e”（有时为“E”）来表示等式的“乘以 10 的幂”部分。例如，1.2 x 10⁴将写为1.2e4，而5.9722 x 10²⁴将写为5.9722e24。对于小于 1 的数，指数可以为负数。该数5e-2相当于5 * 10⁻²，即5 / 10²，或0.05。电子的质量为9.1093837e-31 kg。
Java的垃圾回收机制解说
最新发布
s44359487yad的博客
07-06 1012
JDK 1.7 中的各种垃圾收集器到此已全部介绍完毕，在描述过程中提到了很多虚拟机非稳定的运行参数，在表3-2中整理了这些参数供读者实践时参考。
【JVM】类加载机制
栗子的博客
07-01 672
如果一个类加载器收到了类加载的请求，它首先不会自己去尝试加载这个类，而是把请求委托给父加载器去完成，依次向上，因此，所有的类加载请求最终都应该被传递到顶层的启动类加载器中，只有当父加载器在它的搜索范围中没有找到所需的类时，即无法完成该加载，子加载器才会尝试自己去加载该类。解析阶段是虚拟机将常量池内符号引用转换为直接引用的过程，符号引用包括类和接口的全限定名、变量的名称和描述符号、方法的名称和描述符。直接引用就是指向目标的指针。验证阶段主要进行的是对文件格式的验证、元数据验证、字节码验证和符号引用验证。
多线程二维卷积的n次计算代码
03-28
由于您没有给出具体的问题或数据集，我无法为您提供完整的代码，但我可以给您提供一些思路和伪代码来实现多线程的二维卷积计算。 1. 定义卷积核和输入图像 ``` kernel = [[1, 2, 1], [0, 0, 0], [-1, -2, -1]] # 3x3 Sobel filter image = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]] # 4x4 input image ``` 2. 定义卷积函数 ``` def convolve(kernel, image): # Get kernel and image dimensions kernel_height, kernel_width = len(kernel), len(kernel[0]) image_height, image_width = len(image), len(image[0]) # Initialize output image output = [[0 for _ in range(image_width - kernel_width + 1)] for _ in range(image_height - kernel_height + 1)] # Compute convolution for i in range(kernel_height): for j in range(kernel_width): for k in range(image_height - kernel_height + 1): for l in range(image_width - kernel_width + 1): output[k][l] += kernel[i][j] * image[k+i][l+j] return output ``` 这个函数实现了基本的二维卷积计算，但是它是串行的。我们需要将其并行化以加快计算速度。 3. 定义多线程卷积函数 ``` import threading class ConvolutionThread(threading.Thread): def __init__(self, kernel, image, output, row_start, row_end): threading.Thread.__init__(self) self.kernel = kernel self.image = image self.output = output self.row_start = row_start self.row_end = row_end def run(self): # Get kernel and image dimensions kernel_height, kernel_width = len(self.kernel), len(self.kernel[0]) image_height, image_width = len(self.image), len(self.image[0]) # Compute convolution for i in range(kernel_height): for j in range(kernel_width): for k in range(self.row_start, self.row_end): for l in range(image_width - kernel_width + 1): self.output[k][l] += self.kernel[i][j] * self.image[k+i][l+j] def parallel_convolve(kernel, image, num_threads): # Get kernel and image dimensions kernel_height, kernel_width = len(kernel), len(kernel[0]) image_height, image_width = len(image), len(image[0]) # Initialize output image output = [[0 for _ in range(image_width - kernel_width + 1)] for _ in range(image_height - kernel_height + 1)] # Split image into rows for each thread rows_per_thread = (image_height - kernel_height + 1) // num_threads threads = [] for i in range(num_threads): row_start = i * rows_per_thread row_end = row_start + rows_per_thread if i == num_threads - 1: row_end = image_height - kernel_height + 1 thread = ConvolutionThread(kernel, image, output, row_start, row_end) threads.append(thread) # Start threads for thread in threads: thread.start() # Wait for threads to finish for thread in threads: thread.join() return output ``` 这个函数将输入图像分成多个线程处理。每个线程处理一组连续的行。将图像分成多个线程可以大大减少计算时间。 4. 调用多线程函数 ``` num_threads = 4 result = parallel_convolve(kernel, image, num_threads) ``` 这个例子中，我们将输入图像分成4个线程处理。您可以根据计算机的处理器核心数量来选择线程数，以达到最佳性能。 希望这些思路和伪代码能够帮助您实现多线程的二维卷积计算。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值