多线程（二）

最新推荐文章于 2023-04-04 22:30:38 发布
最新推荐文章于 2023-04-04 22:30:38 发布
阅读量118 收藏
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baidu_40931662/article/details/86528430
版权

目录

一.同步问题

1.synchronized（内建锁）实现同步处理

2.synchronized对象锁概念

3.synchronized底层实现

二.synchronized（内建锁）优化

1.CAS(Campare and Swap)

2. Java对象头

3.偏向锁

4.轻量级锁

5.重量级锁

6. 其它优化

 

 

一.同步问题

1.synchronized（内建锁）实现同步处理

实现锁的功能，可以使用synchronized关键字。

使用synchronized关键字处理有两种模式：同步代码块、同步方法。

同步代码块：

使用同步代码块必须设置一个要锁定的对象，一般可以锁定当前对象：this。

注意：同一时刻只有一个线程可以进入同步代码块，但是可以有多个线程进入方法。

package www.like.java;

class MyThread implements Runnable{

    private int ticket = 100;
    @Override
    public void run() {
        for (int i = 0; i < 100; i++){
            synchronized (this){
                if (this.ticket > 0){
                    try {
                        Thread.sleep(20);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+
                            "还剩下"+this.ticket--+"票");
                }
            }
        }
    }
}

public class Test {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        Thread thread1 = new Thread(myThread,"售票人1");
        Thread thread2 = new Thread(myThread,"售票人2");
        Thread thread3 = new Thread(myThread,"售票人3");
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

分析：

三个线程是在同时卖票的，但是在同一时刻，一定只有一个线程在卖票（上锁了，其他线程进不去，在该线程卖出一张票后，解锁，其他的线程才可以进入），而且票数是递减的。

同步方法：

在方法声明上加上synchronized关键字，表示此时只有一个线程可以进入同步方法。

package www.like.java;

class MyThread implements Runnable{

    private int ticket = 100;
    @Override
    public void run() {
       for(int i = 0; i < 1000; i++){
           this.sale();
       }
    }

    public synchronized void sale(){
        if (this.ticket > 0){
            try {
                Thread.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+
                    "还剩下"+this.ticket--+"票");
        }
    }
}

public class Test {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        Thread thread1 = new Thread(myThread,"售票人1");
        Thread thread2 = new Thread(myThread,"售票人2");
        Thread thread3 = new Thread(myThread,"售票人3");
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

同步虽然可以保证数据的完整性（线程安全操作），但是其执行速度会很慢。

 

2.synchronized对象锁概念

我们先来看一段代码：

package www.like.java;

class Sync {

    public synchronized void test(){
        System.out.println("test方法开始，当前线程为"+Thread.currentThread().getName());
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("test方法结束，当前线程为"+Thread.currentThread().getName());
    }
}

class MyThread extends Thread{

    @Override
    public void run() {
        Sync sync = new Sync();
        sync.test();
    }
}

public class Test {
    public static void main(String[] args) {
        for(int i = 0; i < 3; i++){
            Thread thread = new MyThread();
            thread.start();
        }
    }
}

它的运行结果是这样的：

看到这里有的人可能会很奇怪，test()方法不是已经用synchronized修饰了吗，为什么在进入一个线程之后，其他的线程还可以进入呢？

synchronized(this)以及普通的synchronized方法，只能防止多个线程同时执行同一个对象的同步段。

synchronized锁的是括号中的对象而非代码。

再看一下上面的代码，三个线程有三个sync对象，相当于三个线程各上各的锁，互不干扰，所以同时进入test()方法，又同时出来。

但是如果一定要锁住这段代码该怎么办呢？

第一种思路：只要锁住统一个对象就可以了。

package www.like.java;

class Sync {

    public synchronized void test(){
        System.out.println("test方法开始，当前线程为"+Thread.currentThread().getName());
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("test方法结束，当前线程为"+Thread.currentThread().getName());
    }
}

class MyThread implements Runnable{
    private Sync sync;

    public MyThread(Sync sync) {
        this.sync = sync;
    }

    @Override
    public void run() {
        this.sync.test();
    }
}

public class Test {
    public static void main(String[] args) {
        Sync sync = new Sync();
        MyThread myThread = new MyThread(sync);
        for(int i = 0; i < 3; i++){
            Thread thread = new Thread(myThread,"线程"+i);
            thread.start();
        }
    }
}

看一下结果：

 第二种思路：让synchronized锁这个类对应的class对象。（class对象是唯一的）

全局锁：

package www.like.java;

class Sync {

    public synchronized void test(){
        synchronized (Sync.class){
            System.out.println("test方法开始，当前线程为"+Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("test方法结束，当前线程为"+Thread.currentThread().getName());
        }
    }
}

class MyThread extends Thread{

    @Override
    public void run() {
        Sync sync = new Sync();
        sync.test();
    }
}

public class Test {
    public static void main(String[] args) {
        for(int i = 0; i < 3; i++){
            Thread thread = new MyThread();
            thread.start();
        }
    }
}

看一下结果：

 全局锁：锁代码段

  1. 使用类的静态同步方法：synchronized与class共同使用，此时锁的是当前使用的类而非对象。
  2. 在同步代码段中锁当前的class对象：synchronized(类名称.class){}

 

3.synchronized底层实现

同步代码块底层实现：

执行同步代码块首先要执行monitorenter指令，退出时执行monitorexit指令。

使用synchronized实现同步，关键点就是要获取对象的监视器monitor对象。当线程获取到monitor对象后，才可以执行同步代码块，否则就只能等待。同一时刻只有一个线程可以获取到该对象的monitor监视器。

通常一个monitor指令会同时包含多个monitorexit指令。因为JVM要确保所获取的锁无论在正常路径还是异常路径都能正确解锁。

同步方法底层实现：

当使用synchronized标记方法时，字节码会出现一个访问标记：ACC_SYNCHRONIZED。该标记表示在进入该方法时，JVM需要进行monitorenter操作。在退出该方法时，无论是否正常返回，JVM均需要进行monitorexit操作。

当JVM执行monitorenter时，如果目标对象monitor的计数器为0，表示此时该对象没有被其它线程所持有。此时JVM会将该锁对象的持有线程设置为当前线程，并且将monitor计数器加1。

在目标对象的计数器不为0的情况下，如果锁的持有线程时当前线程，JVM可以将计数器再次加1（可重入锁）；否则需要等待，直到持有线程释放该锁。

对象锁（monitor）机制是JVM1.6之前synchronized底层原理，又称为JDK1.6重量级锁，线程的阻塞以及唤醒均需要操作系统由用户态切换到内核态，开销非常大，因此效率很低。

 

二.synchronized（内建锁）优化

1.CAS(Campare and Swap)

悲观锁：线程获取锁（JDK1.6之前内建锁）是一种悲观锁的策略。假设每一次执行临界区代码（访问共享资源）都会产生冲突，所以当前线程获取到锁的同时也会阻塞其他未获取到锁的线程。

乐观锁（CAS操作，无锁操作）：假设所有线程访问共享资源时不会产生冲突，由于不会产生冲突自然就不会阻塞其他线程。因此线程就不会存在阻塞停顿的状态。出现冲突时，无锁操作使用CAS（比较交换）来鉴别线程是否出现冲突，出现冲突就重试当前操作，直到没有冲突为止。

1.1 CAS操作过程

CAS可以通俗的理解为CAS(V,O,N)：

V：当前内存地址实际存放的值

O：预期值（旧值）

N：更新的新值

 当 V = O 时，期望值与内存值相等，该值没有被其它任何线程修改过，即O就是目前最新的值，因此可以将新值N赋给V。反之如果 V != O ，表明该值已经被其它线程修改过了，因此O值并不是当前最新值，返回V，无法修改。

当多个线程使用CAS操作时，只有一个线程会成功，其余线程均失败，失败的线程会重新尝试（自旋）或挂起线程（阻塞）。

内建锁优化前的最大问题在于：在存在线程竞争的情况下会出现线程的阻塞以及唤醒带来的性能问题，这是一种互斥同步（阻塞同步）。

（获取不到锁会将线程挂起，等待释放后再获取，开销很大）

而CAS不是将线程挂起，当CAS失败后会进行一定的尝试操作并非耗时的将线程挂起，也叫非阻塞同步。

（获取不到锁会将线程阻塞，一直不停的尝试获取）

1.2 CAS的问题

  1. ABA问题：解决方法--->使用atomic包提供的AtomicStampedReference类来解决
  2. 自旋会浪费大量的CPU资源：解决方法--->自适应自旋
  3. 公平性

 

2. Java对象头

在同步的时候获取对象的monitor，即获取到对象的锁。那么，对象的锁怎么理解呢？无非就是类似于对象的一个标志，这个标志就是存放Java对象的对象头。

32位JVM Mark Word默认存储结构为：

根据竞争状态的激烈程度，锁会自动升级，锁不能降级（为了提高锁获取与释放的效率）。

对象的Mark Word变化入下图：

四种状态锁：

无锁                  0      01

偏向锁              1      01

轻量级锁                  00

重量级锁                  10

 

3.偏向锁

大多数情况下，锁不仅不存在线程竞争，而且总是由同一个线程多次获得。为了让线程获取锁的开销降低引入偏向锁。

偏向锁是锁状态中最乐观的一种锁：从始至终只有一个线程请求一把锁。

偏向锁只有一次CAS过程，出现在加锁时。

偏向锁的获取：

当一个线程访问同步块并成功获取到锁时，会在对象头和栈帧中的锁记录字段存储锁偏向的线程ID，以后该进程在进入和退出同步块时不需要进行CAS操作来进行加锁和解锁，直接进入。

当线程访问同步块失败时（已经有线程进入），使用CAS竞争锁，并将偏向锁升级为轻量级锁。

 偏向锁用了一种等待竞争出现才释放锁的机制。所以当其他线程竞争偏向锁时，持有偏向锁的线程才会释放偏向锁，并将锁膨胀为轻量级锁（持有偏向锁的线程依然存活的时候）。如果持有线程已经终止，则将锁对象的对象头设置为无锁状态。

 

4.轻量级锁

多个线程在不同的时间段请求同一把锁，也就是不存在锁竞争的情况。针对这种情况，JVM采用了轻量级锁来避免线程的阻塞与唤醒。

轻量级锁不停的CAS。

当多个线程同时竞争同一把锁时，升级为重量级锁。

 

5.重量级锁

重量级锁就是monitor实现。

 

总结：

  1. 偏向锁只会在第一次请求锁时采用CAS操作，并在锁对象的标记字段记录下当前线程地址。在此后的线程运行过程中，持有偏向锁的线程无需加锁操作。（针对的是锁仅会被统一线程持有的状况）
  2. 轻量级锁采用CAS操作，将锁对象标记字段替换为一个指针，指向当前线程栈上的一块空间，存储着锁对象原本的标记字段。（针对的是多个线程在不同时间段申请同一把锁的情况）
  3. 重量级锁会阻塞、唤醒请求加锁的线程。（针对的是多个线程同时竞争同一把锁的情况）JVM采用自适应自旋，来避免面对非常小的同步代码块时，仍会被阻塞和唤醒的状况。

 

6. 其它优化

锁粗化

锁粗化就是将多次连接在一起的加锁、解锁操作合并为一次操作。将多个联系的锁扩展为一个范围更大的锁。

 

锁解除

删除不必要的加锁操作。根据代码逃逸技术，如果判断一段代码中，堆上的数据不会逃逸出当前线程，则认为此代码是线程安全的，无需加锁。

dhiwhdiow
关注
专栏目录
c++多线程简单实现
Ember的博客
08-17 6369
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录一、线程和多线程线程多线程二、c++中的多线程实现1.简介2.具体实现三、代码示例四、问题 一、线程和多线程 线程 线程是操作系统能够进行运算调度的最小单位，被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。 多线程 简单来说线程就是调度和分配的基本单位，因此引入多线程的概念自然也就是提高了调度和分配的效率，从而提高了程序的运行效率。多线程的
c#多线程编程实战（原书第二版）源码
06-21
《C#多线程编程实战（原书第二版）源码》是一本深入探讨C#中多线程技术的专业书籍，其源码提供了丰富的实践示例，帮助读者掌握并发编程的核心概念和技术。在C#中，多线程是实现高性能、响应式应用程序的关键组成部分...
多线程(二)
李阿昀的博客
10-08 1322
线程安全问题这里以简单的卖票程序为例开始本文的讲解，通过运行该卖票程序可以发现有可能打印出0、-1、-2等错票，这就表明多线程的运行出现了安全问题。产生的原因可归纳为两点： 线程任务中有处理到共享的数据。 线程任务中有多条对共享数据的操作。一个线程在操作共享数据的过程中，其他线程参与了运算，造成了数据的错误。 解决办法：只要能保证多条操作共享数据的代码在某一时间段被一条线程所执行，在执行期间不允许其
C++多线程
钟离默的个人博客
08-13 8554
一、多线程简介 C++11 新标准中引入了四个头文件来支持多线程编程，他们分别是<atomic> ，<thread>，<mutex>，<condition_variable>和<future>。 <atomic> ：该头文主要声明了两个类, std::atomic 和 std::atomic_flag，另外还声明了一套 C 风格的原子类型和与 C 兼容的原子操作的函数。 <thread>：该头文件主要声明了 std::th
C# 异步 多线程
wokao253615105的专栏
02-24 4773
转载自https://www.cnblogs.com/doforfuture/p/6293926.html C#中 Thread，Task，Async/Await，IAsyncResult 的那些事儿！ 说起异步，Thread，Task，async/await，IAsyncResult 这些东西肯定是绕不开的，今天就来依次聊聊他们 ...
Linux多线程
mz474920631的博客
03-23 2741
线程一、线程是什么二、线程的优缺点线程的优点线程的缺点线程异常线程用途进程和线程对比三、线程的操作 一、线程是什么 在一个程序里的一个执行路线就叫做线程（thread）。更准确的定义是：线程是“一个进程内部的控制序列”。 一切进程至少都有一个执行线程。 线程在进程内部运行，本质是在进程地址空间内运行。 在Linux系统中，在CPU眼中，看到的PCB都要比传统的进程更加轻量化。 透过进程虚拟地址空间，可以看到进程的大部分资源，将进程资源合理分配给每个执行流，就形成了线程执行流。 这里再介绍一下进程和线程的概念
QT多线程编程详解
热门推荐
coolboywjun的专栏
04-24 8万+
一、线程基础 1、GUI线程与工作线程 每个程序启动后拥有的第一个线程称为主线程，即GUI线程。QT中所有的组件类和几个相关的类只能工作在GUI线程，不能工作在次线程，次线程即工作线程，主要负责处理GUI线程卸下的工作。 2、数据的同步访问 每个线程都有自己的栈，因此每个线程都要自己的调用历史和本地变量。线程共享相同的地址空间。 二、QT多线程简介 QT通过三种形式提供了对线程...
多线程入门
南风的博客
03-29 7642
多线程 感谢狂神说 java --秦疆老师的教学，教学视频地址 创建线程方式一 //创建线程方式一： 继承Thread类，重写run()方法，调用start开启线程 public class ThreadDemo extends Thread { @Override public void run() { //run方法线程体 for (int i = 0; i < 20; i++) { System.out.println("我在看" + i);
【多线程】线程池
最新发布
王佑辉的博客
04-04 5697
3.keepAliveTime：多余的空闲线程的存活时间，当前线程池数量超过corePoolSize时，当空闲时间达到keepAliveTime时，多余空闲线程会被销毁直到只剩下corePoolSize个线程为止。7.handler：拒绝策略，表示当队列满了并且工作线程-大于等于线程池的数量最大线程数（maxinumPoolSize）时如何来拒绝请求执行的runnable的策略。6.threadFactory：表示生成线程池中工作线程的线程工厂，用于创建线程一般用默认的即可。
C#.NET多线程实例6个(包括多线程基本使用，多线程互斥等全部多线程使用实例),可直接运行
01-31
在.NET框架中，C#语言提供了强大的多线程支持，使得开发者可以充分利用现代多核处理器的优势，实现并行处理和高效能编程。本资源包含六个C#.NET多线程的实例，涵盖了多线程的基本使用到更高级的概念，如线程互斥。...
QT中利用TCP协议实现了一个多线程的文件互传系统
06-09
在QT框架下，利用TCP协议实现一个多线程的文件互传系统是一项常见的任务，它涉及到网络编程、多线程处理以及文件操作等多个方面。本文将深入探讨这些关键知识点。 首先，TCP（Transmission Control Protocol）是一...
C# UDP多线程发送接收
01-23
总结，C# UDP多线程通信是网络编程中的一个重要实践，它结合了UDP的高效传输特性和多线程的并发优势，适用于处理大量并发的网络请求。在实际项目中，开发者需要根据具体需求选择合适的同步机制，保证程序的稳定性和...
Java中保留小数位的几种方法
menqiqi_的博客
08-04 1万+
昨天做了网易的笔试题，选择题都不是很难，但是在做到第一个编程题的时候就被卡住了。不是因为题目有多难，主要卡在了题目上要求保留6位小数，这就非常尴尬了，结果都做对了，就是不会保留，导致题目的通过率为0。在考试结束后就立马查了一些资料，发现了几种保留小数位的方法，都很实用，总结如下： 1.ROUND_UP：远离0方向舍入。即只要弃位非0就进一位。 其实调用的就是BigDecimal类中的setSc...
Properties类的load方法
menqiqi_的博客
09-02 7926
我们先看一下load方法的源码： public synchronized void load(InputStream inStream) throws IOException { load0(new LineReader(inStream)); } 传入了一个输入流，然后调用了load0方法。 再看一下load0方法： private void load0 (L...
多线程（四）
menqiqi_的博客
01-25 718
目录 一. 初识Lock与AbstractQueuedSynchronizer（AQS） 1. Lock简介 2. Lock常用API 3. 初识AQS（队列同步器） 4. AQS的模板模式 5. AQS详解 二. ReentrantLock（独占式重入锁） 1. 重入的实现 2. 公平锁OR非公平锁 三. 可重入读写锁---ReentrantReadWriteLock详解 ...
抽象类
menqiqi_的博客
10-29 714
目录   抽象类的定义与使用 定义 抽象类的使用原则 抽象类的相关规定 抽象类的应用——模板设计模式 抽象类的定义与使用 定义 抽象类只是在普通类的基础上扩充了一些抽象方法而已。 抽象方法：指的是只声明而未实现的方法（没有方法体）。 所有抽象方法要求使用abstract来定义，并且抽象方法所在的类也一定要使用abstract来定义，表示抽象类。 抽象类的使用原则 1.所...
Java中特殊的类---String类
menqiqi_的博客
11-04 525
目录 String类的两种实例化方式 字符串相等比较 字符串常量是String的匿名对象 String类的两种实例化区别 字符串常量不可变更 字符与字符串 字节与字符串 字符串比较  字符串查找 字符串替换 字符串拆分 字符串截取 String类的其它方法 StringBuffer类 1.字符串修改 2.字符串反转 3.删除指定范围的数据 4.插入数据 Str...
Windows多线程编程指南
**二、多线程概述** 多线程允许程序同时执行多个独立的执行流，每个执行流称为一个线程。线程共享同一进程的内存空间，包括全局变量和静态变量，但拥有各自的调用栈，可以独立执行任务。 **三、Win32 API对多线程的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值