多线程之synchronized同步语句块（1）

最新推荐文章于 2024-11-08 14:58:24 发布
最新推荐文章于 2024-11-08 14:58:24 发布
阅读量211 收藏
点赞数
文章标签： 多线程 java thread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_27581753/article/details/105913336
版权
本文深入探讨了Java中使用synchronized关键字声明方法的弊端，并通过示例代码展示了如何利用synchronized同步代码块来优化线程同步，实现部分同步、部分异步的执行效果，从而提高程序的执行效率。
摘要由CSDN通过智能技术生成

用关键字synchronized声明方法在某些情况下是有弊端的，比如A线程调用公布方法执行一个长时间的任务，那么B线程则必须等待比较长时间。在这样的情况下可以使用synchronized同步语句块来解决。

1.synchronized方法的弊端

我们来证明一下synchronized关键字声明方法是有弊端的。
代码示例：
方法类：

package test;

/**
 * @Author LiBinquan
 */
public class Task {
    private String getData1;
    private String getData2;
    public synchronized void doLongTimeTask(){
        try{
            System.out.println("开始 task");
            Thread.sleep(3000);
            getData1 = "长时间处理任务后远程返回的值 1 threadName = "+Thread.currentThread().getName();
            getData2 = "长时间处理任务后远程返回的值 2 threadName = "+Thread.currentThread().getName();
            System.out.println(getData1);
            System.out.println(getData2);
            System.out.println("end");
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

工具类：

package test;

/**
 * @Author LiBinquan
 */
public class CommonUtils {
    public static long beginTime1;
    public static long endTime1;
    public static long beginTime2;
    public static long endTime2;

}

线程1：

package test;


/**
 * @Author LiBinquan
 */
public class ThreadTest1 extends Thread{
    private Task task;
    public  ThreadTest1(Task task){
        super();
        this.task = task;
    }

    @Override
    public void run() {
        super.run();
        CommonUtils.beginTime1 = System.currentTimeMillis();
        task.doLongTimeTask();
        CommonUtils.endTime1 = System.currentTimeMillis();
    }
}

线程2：

package test;


/**
 * @Author LiBinquan
 */
public class ThreadTest2 extends Thread{
    private Task task;
    public  ThreadTest2(Task task){
        super();
        this.task = task;
    }

    @Override
    public void run() {
        super.run();
        CommonUtils.beginTime2 = System.currentTimeMillis();
        task.doLongTimeTask();
        CommonUtils.endTime2 = System.currentTimeMillis();
    }
}

运行类：

package test;

/**
 * @Author LiBinquan
 */
public class Run {
    public static void main(String[] args) throws InterruptedException {
        Task task = new Task();
        ThreadTest1 threadTest1 = new ThreadTest1(task);
        threadTest1.start();
        ThreadTest2 threadTest2 = new ThreadTest2(task);
        threadTest2.start();
        try{
            Thread.sleep(10000);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        long beginTime = CommonUtils.beginTime1;
        if(CommonUtils.beginTime2 < CommonUtils.beginTime1){
            beginTime = CommonUtils.beginTime2;
        }
        long endTime = CommonUtils.endTime1;
        if(CommonUtils.endTime2 < CommonUtils.endTime1){
            endTime = CommonUtils.endTime2;
        }
        System.out.println("耗时："+ (endTime - beginTime)/1000);
    }
}

输出：
在这里插入图片描述
在使用synchronized关键字俩声明方法 public synchronized void doLongTimeTask()时从运行的时间上来看，弊端很明显，解决这样的问题可以使用synchronized同步块。

2.synchronized同步代码块的使用

当两个并发线程访问同一个对象object中的synchronized(this)同步代码块时，一段时间内只能有一个线程被执行，另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。
示例代码：
方法类：

package test;

/**
 * @Author LiBinquan
 */
public class ObjectService {
    public void serviceMethod(){
        try{
            synchronized (this){
                System.out.println("begin beginTime = "+System.currentTimeMillis());
                Thread.sleep(2000);
                System.out.println("end     endTime = "+System.currentTimeMillis());
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

线程1：

package test;


/**
 * @Author LiBinquan
 */
public class ThreadTest1 extends Thread{
    private ObjectService service;
    public ThreadTest1(ObjectService service){
        super();
        this.service = service;
    }

    @Override
    public void run() {
        super.run();
        service.serviceMethod();
    }
}

线程2：

package test;


/**
 * @Author LiBinquan
 */
public class ThreadTest2 extends Thread{
    private ObjectService service;
    public ThreadTest2(ObjectService service){
        super();
        this.service = service;
    }

    @Override
    public void run() {
        super.run();
        service.serviceMethod();
    }
}

运行类：

package test;

/**
 * @Author LiBinquan
 */
public class Run {
    public static void main(String[] args) throws InterruptedException {
        ObjectService service = new ObjectService();
        ThreadTest1 threadTest1 = new ThreadTest1(service);
        threadTest1.setName("A");
        threadTest1.start();
        ThreadTest2 threadTest2 = new ThreadTest2(service);
        threadTest2.setName("B");
        threadTest2.start();
    }
}

输出：
在这里插入图片描述
虽然这个示例中我们使用了synchronized同步代码块，但执行的效率还是没有提高，执行的效果还是同步运行的。

3.同步代码块来解决同步方法的弊端

这边修改一下 上面的方法就行，代码如下：

package test;

/**
 * @Author LiBinquan
 */
public class Task {
    private String getData1;
    private String getData2;
    public void doLongTimeTask(){
        try{
            System.out.println("开始 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");
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

输出：
在这里插入图片描述
通过上面的测试可以得知，当一个线程访问object的一个synchronized同步代码块时，另一个线程仍然可以访问该object对象中的非synchronized(this)同步代码块。
这边我们可以看到运行时间缩短但是同步synchronized代码块真的是同步的吗？真的持有当前调用对象的锁吗？答案为：是 ，这边我们就需要验证一下。

4.一半异步，一半同步

这边我们要证明一点：不在synchronized块中就是异步执行，在synchronized块中就是同步执行。
方法类：

package test;

/**
 * @Author LiBinquan
 */
public class Task {
    public void doLongTimeTask(){
        for (int i = 0; i < 100; i++) {
            System.out.println("非同步代码块 线程名 = "+Thread.currentThread().getName()+ " i = "+(i +1));
        }
        synchronized (this){
            for (int i = 0; i < 100; i++) {
                System.out.println("同步代码块  线程名 = "+Thread.currentThread().getName()+ " i = "+(i +1));
            }        
        }
    }
}

线程1：

package test;


/**
 * @Author LiBinquan
 */
public class ThreadTest1 extends Thread{
    private Task task;
    public  ThreadTest1(Task task){
        super();
        this.task = task;
    }

    @Override
    public void run() {
        super.run();
        task.doLongTimeTask();
    }
}

线程2：

package test;


/**
 * @Author LiBinquan
 */
public class ThreadTest2 extends Thread{
    private Task task;
    public  ThreadTest2(Task task){
        super();
        this.task = task;
    }

    @Override
    public void run() {
        super.run();
        task.doLongTimeTask();
    }
}

运行类：

package test;

/**
 * @Author LiBinquan
 */
public class Run {
    public static void main(String[] args) throws InterruptedException {
        Task task = new Task();
        ThreadTest1 threadTest1 = new ThreadTest1(task);
        threadTest1.start();
        ThreadTest2 threadTest2 = new ThreadTest2(task);
        threadTest2.start();
    }
}

输出：
在这里插入图片描述
非同步代码块交叉打印

在这里插入图片描述
同步代码块排队执行

道墟
关注
java多线程synchronized用法
lianggx3的博客
11-19 186
1. synchronized同步方法 方法声明时使用,放在范围操作符(public等)之后,返回类型声明(void等)之前。 在两个线程访问同一对象中的同步方法时一定是线程安全的。 即一次只能有一个线程进入该方法,其他线程要想在此时调用该方法,只能排队等候,当前线程(就是在synchronized方法内部的线程)执行完该方法后,别的线程才能进入。 public class Mythre...
java多线程编程之使用Synchronized块同步方法
weixin_34019144的博客
10-19 59
synchronized块来同步一个对象变量,也可以使用synchronized块来同步类中的静态方法和非静态方法,下面使用Synchronized块同步方法 synchronized关键字有两种用法。第一种就是在《使用Synchronized关键字同步类方法》一文中所介绍的直接用在方法的定义中。 另外一种就是synchronized块。我们不仅可以通过synchronized块来同步一个对象变...
synchronized同步代码块
wuzhan的专栏
05-30 198
并发线程在访问 synchronized(this) 同步代码块时，一段时间内只能有一个线程被执行，另一个线程必须等待当前线程执行完这个代码块后才能执行； 示例代码： Task.java package com.daimakuai; /** * @Auther: 13213 * @Date: 2020/5/30 17:59 * @Description: */ public class Task { public void doLongTimeTask(){ fo
Java多线程笔记（二）--synchronized同步语句块
云端做梦
07-22 329
亲爱的观众朋友们，你们好！这是多线程笔记的第二篇文章，这一章主要是学习一下对象以及变量的并发访问。 学习完本章主要掌握以下技术点： synchronized对象监视器Object时的使用。 synchronized对象监视器Class时的使用。 非线程安全是如何出现的。 关键字volatile的主要作用。 关键字volatile与 synchronized...
Java多线程编程二(synchronized同步方法和synchronized同步代码块）
qq_33225399的博客
02-20 1309
对象及变量的并发访问一、synchronized同步方法 本文主要讲述如何解决非线程安全问题 一、synchronized同步方法 方法内的变量为线程安全 “非线程安全“问题存在与实例变量中，如果是方法内部的私有变量，则不存在“非线程安全“问题，也就是线程安全的。 public class MyThread extends Thread { @Override public v...
【Java多线程】synchronized同步语句块
热门推荐
一定要站在自己热爱的生活里闪闪发光
10-11 4万+
synchronized方法是对当前对象进行加锁，而synchronized代码块是对某一个对象进行加锁。 1.synchronized方法的弊端 在使用synchronized关键字来声明方法的时，线程需要排队执行，运行时间较长。 2.synchronized同步代码块的使用 当两个并发线程访问同一个对象object中的synchronized(this)同步代码时，一段时间内只能有一个线程被执行，另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。 下面通过一个示例来说..
多线程--synchronized同步语句块
z-xiaoyao
03-25 478
上篇博客说了同步方法，这篇博客我们来看一下同步语句块的相关内容。首先，一起学习一下基础知识。1、使用synchronized关键字声明方法，从运行时间上看，弊端明显2、当一个线程访问object的一个synchronized同步代码块时，另一个线程仍然可以访问该object对象中的非synchronized（this）同步代码块，所以仅将可能发生问题的代码块放即可3、当一个线程访问object的一...
Java 多线程 —— 同步代码块（解决线程安全问题)
一纸春秋的博客
10-23 1万+
目录火车站抢票问题同步代码块同步方法（this锁）同步方法，在public的后面加上synchronized关键字this锁静态同步方法 火车站抢票问题 由于现实中买票也不会是零延迟的，为了真实性加入了延迟机制，也就是线程休眠语句 package test.MyThread.ticketDemo; public class RunnableThread implements Runnable{ private int ticket = 100; @Override public v
24.线程的同步机制-synchronized同步语句-synchronized同步代码块的使用.mp4
04-06
在学习Java过程中，自己收集了很多的Java的学习资料，分享给大家，有需要的欢迎下载，希望对大家有用，一起学习，一起进步。
27.线程的同步机制-synchronized同步语句-synchronized代码块间的同步性.mp4
04-06
在学习Java过程中，自己收集了很多的Java的学习资料，分享给大家，有需要的欢迎下载，希望对大家有用，一起学习，一起进步。
25.线程的同步机制-synchronized同步语句-使用同步代码块解决同步方法的弊端.mp4
04-06
在学习Java过程中，自己收集了很多的Java的学习资料，分享给大家，有需要的欢迎下载，希望对大家有用，一起学习，一起进步。
30.线程的同步机制-synchronized同步语句-静态同步synchronized方法与synchronized(class)代码块.mp4
04-06
在学习Java过程中，自己收集了很多的Java的学习资料，分享给大家，有需要的欢迎下载，希望对大家有用，一起学习，一起进步。
28.线程的同步机制-synchronized同步语句-synchronized(this)代码块是锁定当前对象.mp4
04-06
在学习Java过程中，自己收集了很多的Java的学习资料，分享给大家，有需要的欢迎下载，希望对大家有用，一起学习，一起进步。
spring循环依赖解决方式
qq_36400213的博客
11-04 913
字段注入和setter注入则提供了更多的灵活性，但需要更谨慎地管理对象的状态。方法注入和注解注入则适用于特定的场景。在Spring框架中，依赖注入（Dependency Injection，DI）是一种实现控制反转（Inversion of Control，IoC）的机制，用于将对象的依赖关系自动注入到对象中。这种方式不如构造器注入严格，但比字段注入更灵活，因为它可以在不创建新实例的情况下改变对象的依赖。这种方式是推荐的，因为它可以保证对象在创建时就处于完全初始化的状态，并且可以使得bean不可变。
JAVA-01-变量
最新发布
LJH_laura_li的博客
11-08 188
在方法、构造函数或块内部定义的变量。
2024年华为OD机试真题-查找充电设备-C++-OD统一考试（E卷）
面试高手的博客
11-08 82
某个充电站，可提供n个充电设备只，每个充电设备均有对应的输出功率任意个充电设备组合的输出功率总和，均构成功率集合P的1个元素功率集合P的最优元素，表示最接近充电站最大输出功率pmax 的元素。每一题都含有详细的解题思路和代码注释，精编c++、JAVA、Python三种语言解法。当充电设备输出功率50、20、20组合时，其输出功率总和为90，最接近充电站最大充电输出功率，因此最优元素为90。所有充电设备的输出功率组合，均大于充电站最大充电输出功率30，此时最优元素值为0。第 2 行为每个充电设备的输出功率。
每日OJ题_牛客_相差不超过k的最多数_滑动窗口_C++_Java
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
11-04 447
每日OJ题_牛客_相差不超过k的最多数_滑动窗口_C++_Java（排序容易想，但是滑动窗口不容易想到，核心思想：使用滑动窗口算法通过动态调整窗口的大小，遍历所有符合条件的连续子序列，求得最大连续子序列的长度。）
【Java知识】Java基础-对象排序的实现
wendao76的专栏
11-04 396
方法，并且需要提供一个比较器（Comparator）来定义对象的排序逻辑。这些示例展示了如何在Java中对对象进行排序，无论是使用列表还是数组，都可以灵活地使用比较器来定义排序规则。在Java中，对象的排序通常涉及到使用。
greendao使用封装
白高林的专栏
11-07 331
greenDAO
Java多线程同步：synchronized关键字深度解析
在Java多线程编程中，`synchronized`关键字扮演着至关重要的角色，它提供了线程同步机制，确保共享资源在同一时刻只被一个线程访问，从而避免数据不一致的问题。以下是关于`synchronized`关键字的详细解释： 1. **...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值