《Java多线程编程核心技术》(二)

最新推荐文章于 2024-03-10 23:38:03 发布
最新推荐文章于 2024-03-10 23:38:03 发布
阅读量437 收藏
点赞数
分类专栏： Java 文章标签： synchronized synchronized锁重入
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Jason847/article/details/80613703
版权

非线程安全会在多个线程对同一个对象中的实例变量进行并发访问时发生。产生的后果是脏读，也就是取到的数据其实是被更改过的。
线程安全就是获得的实例变量的值是经过同步处理的，不会出现脏读的现象。

非线程安全问题存在于实例变量中，如果是方法内部的私有变量，则不存在非现场安全问题，所得的结果也就是线程安全的了。

synchronized同步方法

关键字synchronized取得的都是对象锁，而不是把一段代码和方法当做锁。 当多个线程访问同一个对象时，哪个线程先执行带synchronized关键字的方法，哪个线程就持有该方法所属对象的锁Lock。

如果多个线程访问多个对象，则JVM会创建多个锁。

调用关键字synchronized声明的方法一定是排队运行的。
既然使用了synchronized，那么肯定是对“共享”资源的读写访问。

如何查看Lock锁对象的效果呢？

public class MyObject {

    synchronized public void methodA(){
        try {
            System.out.println("begin 执行methodA, 线程为："+Thread.currentThread().getName());
            Thread.sleep(2000);
            System.out.println("end  执行methodA, 线程为："+Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void methodB(){
        try {
            System.out.println("begin 执行methodB, 线程为："+Thread.currentThread().getName());
            Thread.sleep(2000);
            System.out.println("end  执行methodB, 线程为："+Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class Run {

    public static void main(String[] args){
        //同一个实例对象
        MyObject object = new MyObject();

        Thread threadA = new Thread(new Runnable() {
            @Override
            public void run() {
                object.methodA();
            }
        });

        Thread threadB = new Thread(new Runnable() {
            @Override
            public void run() {
                object.methodB();
            }
        });
        //启动两个线程，分别执行methodA和methodB方法
        threadA.start();
        threadB.start();
    }
}
/**
begin 执行methodA, 线程为：Thread-0
begin 执行methodB, 线程为：Thread-1
end  执行methodA, 线程为：Thread-0
end  执行methodB, 线程为：Thread-1
*/

结论：
threadA线程调用了synchronized的methodA，持有了对象锁。但是threadB完全可以异步调用非synchronized的methodB。说明没有满足上述所说的排队执行。

改进：
对methodB增加synchronized关键字

public class MyObject {

    synchronized public void methodA(){
        try {
            System.out.println("begin 执行methodA, 线程为："+Thread.currentThread().getName());
            Thread.sleep(2000);
            System.out.println("end  执行methodA, 线程为："+Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    synchronized public void methodB(){
        try {
            System.out.println("begin 执行methodB, 线程为："+Thread.currentThread().getName());
            Thread.sleep(2000);
            System.out.println("end  执行methodB, 线程为："+Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

/**
begin 执行methodA, 线程为：Thread-0
end  执行methodA, 线程为：Thread-0
begin 执行methodB, 线程为：Thread-1
end  执行methodB, 线程为：Thread-1
*/

结论：
threadA线程调用了synchronized的methodA，持有了对象锁。前者执行完后，threadB才开始执行methodB。满足了上述所说的排队执行。

当A线程调用anyObject对象加入synchronized关键字的X方法时，A线程就获得了X方法锁，更准确地讲，是获得了对象的锁，所以其他线程必须等A线程执行完毕才可以调用X方法，但B线程可以随意调用其他的非synchronized同步方法。

当A线程调用anyObject对象加入synchronized关键字的X方法时，A线程就获得了X方法所在对象的锁，所以其他线程必须等A线程执行完毕才可以调用X方法，而B线程如果调用声明了synchronized关键字的非X方法时，必须等A线程将X方法执行完，也就是释放对象锁后才可以调用。

synchronized锁重入

关键字synchronized拥有锁重入的功能，也就是在使用synchronized时，当一个线程得到一个对象锁后，再次请求此对象锁时是可以再次得到该对象的锁的。这也证明在一个synchronized方法/块的内部调用本类的其他synchronized方法/块时，是永远可以得到锁的。

“可重入锁”的概念是：自己可以再次获取自己的内部锁。

比如有1条线程获得了某个对象的锁，此时这个对象锁还没有释放，当其再次想要获取这个对象的锁的时候还是可以获取的，如果不可锁重入的话，就会造成死锁。

public class Service {

    public synchronized void service1(){
        System.out.println("service1");
        service2();
    }

    public synchronized void service2(){
        System.out.println("service2");
        service3();
    }

    public synchronized void service3(){
        System.out.println("service3");

    }
}
public class Run {
    public static void main(String[] args){
        Service service = new Service();
        new Thread(new Runnable() {
            @Override
            public void run() {
                service.service1();
            }
        }).start();
    }
}
/**
service1
service2
service3
*/

可重入锁也支持在父子类继承的环境中，子类的同步方法可以调用父类的同步方法。

synchronized同步语句块

使用synchronized同步代码块，一方面缩小了需要同步的范围，提高了程序的执行效率。另一方面，可以指定锁对象。

使用格式：synchronized(this){ …. }

public class Task {
    private String getData1;
    private String getData2;

    public void doLongTimeTask(){
        try {
            System.out.println("begin task");
            Thread.sleep(3000);
            String privateGetData1 = "长时间处理任务后从远程返回的值1 threadName="
                    + Thread.currentThread().getName();
            String privateGetData2 = "长时间处理任务后从远程返回的值2 threadName="
                    + Thread.currentThread().getName();
            synchronized (this) {
                getData1 = privateGetData1;
                getData2 = privateGetData2;
            }
            System.out.println(getData1);
            System.out.println(getData2);
            System.out.println("end task");
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

如果使用同步方法，则每个线程都需要排队执行，导致每个线程最少执行3秒。而真正需要同步的地方只有getData1和getData2的赋值操作。耗时的操作没必要同步执行。

任意对象作为对象监视器

使用格式：synchronized(非this对象){ …. }

优点：
如果在一个类中有很多个synchronized方法，这时虽然能实现同步，但会受到阻塞，所以影响运行效率；但如果使用同步代码块锁非this对象，则synchronized（非this）代码块中的程序与同步方法是异步的，不与其他锁this同步方法争抢this锁，则可大大提高运行效率。

对象监视器不同，运行结果就是异步调用了。

public class MyObject {
    synchronized public void methodC(){
        try {
            System.out.println("methodC ____getLock time="
                    + System.currentTimeMillis() + " run ThreadName="
                    + Thread.currentThread().getName());
            Thread.sleep(2000);
            System.out.println("methodC releaseLock time="
                    + System.currentTimeMillis() + " run ThreadName="
                    + Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
public class Service {
    public void testMethod1(MyObject object) {
        synchronized (object) {
            try {
                System.out.println("testMethod1 ____getLock time="
                        + System.currentTimeMillis() + " run ThreadName="
                        + Thread.currentThread().getName());
                Thread.sleep(5000);
                System.out.println("testMethod1 releaseLock time="
                        + System.currentTimeMillis() + " run ThreadName="
                        + Thread.currentThread().getName());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class Run {
    public static void main(String[] args){
        MyObject object = new MyObject();
        Service service = new Service();
        // 同步方法和同步代码块使用的是同一个对象锁object，结果同步打印
        new Thread(new Runnable() {
            @Override
            public void run() {
                object.methodC();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                service.testMethod1(object);
            }
        }).start();
    }
}
/**
methodC ____getLock time=1528446201224 run ThreadName=Thread-0
methodC releaseLock time=1528446203224 run ThreadName=Thread-0
testMethod1 ____getLock time=1528446203224 run ThreadName=Thread-1
testMethod1 releaseLock time=1528446208225 run ThreadName=Thread-1
*/

静态同步synchronized方法与synchronized（class）代码块

synchronized关键字加到static静态方法上是给Class类上锁，而synchronized关键字加到非static静态方法上是给对象上锁。

证明不是同一个锁：

public class Service {
    public synchronized void testMethod1() {
        try {
            System.out.println("testMethod1 ____getLock time="
                    + System.currentTimeMillis() + " run ThreadName="
                    + Thread.currentThread().getName());
            Thread.sleep(5000);
            System.out.println("testMethod1 releaseLock time="
                    + System.currentTimeMillis() + " run ThreadName="
                    + Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    synchronized public static void printA() {
        try {
            System.out.println("线程名称为：" + Thread.currentThread().getName()
                    + "在" + System.currentTimeMillis() + "进入printA");
            Thread.sleep(3000);
            System.out.println("线程名称为：" + Thread.currentThread().getName()
                    + "在" + System.currentTimeMillis() + "离开printA");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
public class Run {

    public static void main(String[] args){
        //异步执行
        Service service = new Service();
        new Thread(new Runnable() {
            @Override
            public void run() {
                service.testMethod1();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                service.printA();
            }
        }).start();
    }
}
/**
testMethod1 ____getLock time=1528448721070 run ThreadName=Thread-0
线程名称为：Thread-1在1528448721070进入printA
线程名称为：Thread-1在1528448724070离开printA
testMethod1 releaseLock time=1528448726070 run ThreadName=Thread-0
*/

volatile关键字

作用：
  1. 使变量在多个线程间可见（只修饰于变量）
  2. 强制从公共堆栈中取得变量的值，而不是从线程私有数据栈中取得变量的值

这里写图片描述

比较（与synchronized不同）


  2. 关键字volatile是线程同步的轻量级实现，所以volatile性能肯定比synchronized要好，并且volatile只能修饰于变量，而synchronized可以修饰方法，以及代码块。随着JDK新版本的发布，synchronized关键字在执行效率上得到很大提升，在开发中使用synchronized关键字的比率还是比较大的。
  3. 多线程访问volatile不会发生阻塞，而synchronized会出现阻塞。
  4. volatile能保证数据的可见性，但不能保证原子性；而synchronized可以保证原子性，也可以间接保证可见性，因为它会将私有内存和公共内存中的数据做同步。
  5. 再次重申一下，关键字volatile解决的是变量在多个线程之间的可见性；而synchronized关键字解决的是多个线程之间访问资源的同步性。

线程安全包含原子性和可见性两个方面，Java的同步机制都是围绕这两个方面来确保线程安全的。

应用场景

应用场景是在多个线程中可以感知实例变量被更改了，并且可以获得最新的值使用，也就是用多线程读取共享变量时可以获得最新值使用。（仅仅是读取最新的值）

关键字volatile提示线程每次从共享内存中读取变量，而不是从私有内存中读取，这样就保证了同步数据的可见性。但在这里需要注意的是：如果修改实例变量中的数据，比如i++，也就是i=i+1，则这样的操作其实并不是一个原子操作，也就是非线程安全的。表达式i++的操作步骤分解如下：
1）从内存中取出i的值；
2）计算i的值；
3）将i的值写到内存中。
假如在第2步计算值的时候，另外一个线程也修改i的值，那么这个时候就会出现脏数据。解决的办法其实就是使用synchronized关键字，所以说volatile本身并不处理数据的原子性，而是强制对数据的读写及时影响到主内存的。

青菜小王子
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java多线程编程核心技术.zip
09-24
本资料"Java多线程编程核心技术.zip"深入探讨了这些核心技术，并提供了源码供学习者实践和理解。 1. **线程的创建与启动** - 继承Thread类：自定义类继承Thread类，重写run()方法，然后创建该类对象并调用start()...
JAVA多线程编程技术PDF
08-28
这份“JAVA多线程编程技术PDF”是学习和掌握这一领域的经典资料，涵盖了多线程的全部知识点。 首先，多线程的核心概念包括线程的创建与启动。在Java中，可以通过实现Runnable接口或继承Thread类来创建线程。创建后...
源码分享—《Java多线程编程核心技术》源码，Java多线程编程核心技术源码 略微有改动。
苡仁
01-14 1756
java-multi-thread-ilss Github地址：https://github.com/ilssio/java-multi-thread-ilss 《Java多线程编程核心技术》书上案例代码 基本和书上是一样的。 每一部分都是按照书上说 创建什么项目 就直接用做包最后一层的名字，全部小写，中间加下划线。java不推荐包名大小写混用。 part几就是第几章，第一章没有，自己过一遍就好了...
Java 多线程编程基础(详细)
一夜星尘
11-03 3万+
Java多线程编程基础进程与线程多线程实现Thread类实现多线程Runnable接口实现多线程Callable接口实现多线程多线程运行状态多线程常用操作方法线程的命名和获取线程休眠线程中断线程强制执行线程让步线程优先级设定线程的同步和锁死线程同步处理线程死锁 进程与线程 进程与线程的基本认识 进程（Process）：进程是程序的一次动态执行过程，它经历了从代码加载、执行、到执行完毕的一个完整过程；同时也是并发执行的程序在执行过程中分配和管理资源的基本单位，竞争计算机系统资源的基本单位。 线程（Thread
Java多线程实战-实现多线程文件下载，支持断点续传、日志记录等功能
热门推荐
qq_35716689的博客
03-10 16万+
本文将介绍如何通过Java来实现一个多线程下载器。作者：牵着猫散步的鼠鼠
编程必备：JAVA多线程详解
拾一二的博客
06-14 7917
多线程已经成为一种常见的编程模式，广泛应用于各种不同类型的应用程序中。本篇博客文章中，我们将会探讨多线程编程的相关知识和技巧。通过代码示例和实际应用案例来深入了解多线程的具体实现和应用方法，帮助更好地掌握多线程编程技术，提高程序效率和性能。后期随学习深入还会补充修改。以上就是我对多线程的个人简介，后续会不断完善更新，与大家共勉。
《java多线程编程核心技术》之java多线程技能
sjtu_chenchen的专栏
12-13 660
高洪岩书籍第一章总结：
万字图解Java多线程
qq_35598736的博客
09-06 6万+
前言 java多线程我个人觉得是javaSe中最难的一部分，我以前也是感觉学会了，但是真正有多线程的需求却不知道怎么下手，实际上还是对多线程这块知识了解不深刻，不知道多线程api的应用场景，不知道多线程的运行流程等等，本篇文章将使用实例+图解+源码的方式来解析java多线程。 文章篇幅较长，大家也可以有选择的看具体章节，建议多线程的代码全部手敲，永远不要相信你看到的结论，自己编码后运行出来的，才是自己的。 什么是java多线程? 进程与线程 进程 当一个程序被运行，就开启了一个进程， 比如启动了qq，w.
《Java多线程编程核心技术》推荐
小宝鸽
03-04 2万+
写这篇博客主要是给猿友们推荐一本书《Java多线程编程核心技术》。之所以要推荐它，主要因为这本书写得十分通俗易懂，以实例贯穿整本书，使得原本抽象的概念，理解起来不再抽象。只要你有一点点Java基础，你就可以尝试去阅读它，相信定会收获甚大！博主之前网上找了很久都没pdf电子版的，只有不全的阅读版，这里博主提供免费清晰完整版供各位猿友下载： http://download.csdn.net/detai
《Java多线程编程核心技术》（一）多线程技能
一名java从业者的专栏
09-20 2043
最近阅读了一本《Java多线程编程核心技术》，总结了一下每章的知识点：第一章，java多线程技能 知识点：1，实现多线程编程的方式主要有两种：一是继承Thread类，重新run方法，二是实现Runnable接口，实现run方法，对象作为构造参数传入Thread对象进行start()启动。（第二种方式支持多继承情况）2，currentThread()方法可以返回代码段正在被哪个线程调用的信息。 Th
《Java多线程编程核心技术》学习笔记（1）
洋YANG的博客
02-23 1万+
一、实现多线程的编程方式 （1）继承Thread类 public class MyThread extends Thread { @Override public void run() { super.run(); System.out.println("MyThread"); } } public class Run { publi
《Java多线程编程核心技术》——多线程总结
weixin_39754631的博客
03-28 3643
第1章 Java多线程技能 本章主要介绍线程和进程的相关概念，多线程的实现和停止，以及Thread类中的核心方法，具体实现的代码可以参考《Java多线程编程核心技术》。 进程和线程 1.进程 一个可并发执行的具有独立功能的程序关于某个数据集合的一次执行过程，也是操作系统进行资源分配和保护的基本单位。简单的说，进程就是一个程序的一次执行过程。 2.引入线程的动机和思路 操作系统采用进程机制使得多任务...
java多线程并发编程 核心技术应用实践
06-21
在《java多线程并发编程核心技术应用实践》中，我们将深入探讨Java平台上的并发机制、线程安全与同步控制、线程池以及实战技巧。 首先，我们需要理解Java中的线程基础。线程是程序执行的最小单位，一个进程可以有多...
Java多线程编程技术
03-26
《Java多线程编程核心技术》建议猿友们读两遍，因为其写得没有那么抽象，第一遍有些概念不是很理解，可以先跳过并记录起来，第一遍阅读的目的主要是了解整个架构。第二遍再慢慢品味，并贯穿全部是指点来思考，并将...
Java多线程编程核心技术_完整版_java_
09-30
本教程《Java多线程编程核心技术》将深入探讨这一主题。 一、线程的创建与启动 1. 继承Thread类：创建一个新的类，该类继承自Thread类，然后重写run()方法，最后创建该类的实例并调用start()方法启动线程。 2. 实现...
pi_heif-0.17.0-cp310-cp310-manylinux_2_17_aarch64.whl
07-27
pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。
Numper基础（一）
07-27
Numper基础（一）
C语言写的潮流计算大作业代码.zip
最新发布
07-27
c写的潮流计算大作业代码.zipc写的潮流计算大作业代码.zipc写的潮流计算大作业代码.zip
关于大模型的教程、调用和使用技巧的资源，帮助更多人高效地认知和使用大模型.docx
07-27
大模型（Large Models），尤其是指预训练的大规模语言模型，在自然语言处理（NLP）、计算机视觉（CV）等领域取得了显著的进步。以下是一些关于大模型的教程、调用和使用技巧的资源，帮助更多人高效地认知和使用大模型： 1. 大模型教程资源 官方文档： 大多数大型模型都会在其官方网站或GitHub页面上发布详细的文档，包括模型介绍、安装指南、使用示例等。 例如，Hugging Face的Transformers库提供了丰富的文档和教程。 在线课程： Coursera、edX等在线教育平台上提供了关于大模型的课程。 例如，斯坦福大学的NLP课程通常会涵盖最新的大模型技术。 博客文章： Medium、Towards Data Science等平台上有很多关于大模型的文章，这些文章通常由专业人士撰写，包含实战经验和技巧。 视频教程： B站（bilibili.com）和YouTube上有很多关于大模型的教程视频，适合初学者入门。 2. 调用API和使用技巧 Hugging Face Transformers： 提供了多种预训练模型的加载和调用方式。 Hugging Face文档 是一个非常
Java多线程编程核心技术详解与实战
"《Java多线程编程核心技术》是一本由高洪岩撰写的专著，作为'Java核心技术系列'的一部分，它深入探讨了Java多线程编程的关键技术和实践。本书旨在弥补市场上同类教材的不足，即缺乏对Java多线程技术的全面覆盖。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

青菜小王子

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值