Java多线程编程笔记3：synchronized同步语句块

最新推荐文章于 2024-08-03 17:05:14 发布
最新推荐文章于 2024-08-03 17:05:14 发布
阅读量97 收藏
点赞数
文章标签： java
原文链接：https://juejin.im/post/5c0b9dc4e51d45022a15db8a
版权

使用synchronized关键字声明方法有些时候是有很大的弊端的，比如我们有两个线程一个线程A调用同步方法后获得锁，那么另一个线程B就需要等待A执行完，但是如果说A执行的是一个很费时间的任务的话这样就会很耗时。

synchronized(this)同步代码块

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

一个线程访问object的一个同步代码块时，另外一个线程仍然可以访问该对象的非同步代码块。 以下代码可以证明：不在synchronized块中就是异步执行，在synchronized块中就是同步执行。

class Task{
    public void doLongTimeTask(){
        for (int i=0;i<5;i++){
            System.out.println("nonsync threadName:"+Thread.currentThread().getName()+" i: "+i);
        }
        System.out.println();
        synchronized (this){
            for (int i=0;i<5;i++){
                System.out.println("sync threadName:"+Thread.currentThread().getName()+" i: "+i);
            }
        }
    }
}

class MyThread extends Thread{
    private Task task;
    public MyThread(Task task){
        this.task=task;
    }

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


public class Run {
    public static void main(String[] args) {
        Task task=new Task();
        MyThread t1=new MyThread(task);
        MyThread t2=new MyThread(task);
        t1.start();
        t2.start();
    }
}
复制代码

运行结果为：

nonsync threadName:Thread-0 i: 0
nonsync threadName:Thread-1 i: 0
nonsync threadName:Thread-0 i: 1
nonsync threadName:Thread-1 i: 1
nonsync threadName:Thread-1 i: 2
nonsync threadName:Thread-1 i: 3
nonsync threadName:Thread-0 i: 2
nonsync threadName:Thread-1 i: 4
nonsync threadName:Thread-0 i: 3

nonsync threadName:Thread-0 i: 4

sync threadName:Thread-1 i: 0
sync threadName:Thread-1 i: 1
sync threadName:Thread-1 i: 2
sync threadName:Thread-1 i: 3
sync threadName:Thread-1 i: 4
sync threadName:Thread-0 i: 0
sync threadName:Thread-0 i: 1
sync threadName:Thread-0 i: 2
sync threadName:Thread-0 i: 3
sync threadName:Thread-0 i: 4
复制代码

可以看到，非同步代码块是异步执行的，同步代码块则是排队执行的。

同步代码块之间的同步性：在使用synchronized(this)代码块时，当一个线程访问object的一个同步代码块时，其他线程对同一个对象中所有其他synchronized(this)代码块的访问会被阻塞，说明synchronized使用的“对象监视器是一个”。

synchronized(this)代码块是锁定当前对象的。也就是说，多个线程调用同一个对象的不同名称的synchronized同步方法或者synchronized(this)同步代码块时，调用的效果就是按顺序执行，就是同步的，阻塞的。也就是说，无论是同步方法或者synchronized(this)代码块，都可以对其他同步方法或代码块调用呈阻塞状态。同一时间只有一个线程可以执行同步方法或同步代码块中的代码。

synchronized(非this对象)代码块

除了synchronized(this)同步代码块，Java还支持对任意对象作为“对象监视器”来实现同步的功能。任意对象大多数是实例变量及方法的参数。同样的，在多个线程持有“对象监视器”为同一个对象的前提下，同一时间只有一个线程可以执行synchronized(非this)同步代码块中的代码。

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

在使用synchronized(非this对象)同步代码块时，对象监视器必须是同一个对象，如果不是同一个对象监视器，运行的结果就是异步调用了。示例代码：

package ch02.t12;

class Service {
    private String anyStr = new String();

    public void method() {
        try {
            synchronized (anyStr) {
                System.out.println("Thread: " + Thread.currentThread().getName()
                        + " time: " + System.currentTimeMillis() + "进入同步块");
                Thread.sleep(3000);
                System.out.println("Thread: " + Thread.currentThread().getName()
                        + " time: " + System.currentTimeMillis() + "离开同步块");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class MyThread extends Thread{
    private Service service;
    public MyThread(Service service){
        this.service=service;
    }

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

public class Run {
    public static void main(String[] args) {
        Service service=new Service();
        MyThread a=new MyThread(service);
        a.setName("A");
        a.start();

        MyThread b=new MyThread(service);
        b.setName("B");
        b.start();
    }
}
复制代码

运行结果为：

Thread: A time: 1544337130842进入同步块
Thread: A time: 1544337133842离开同步块
Thread: B time: 1544337133842进入同步块
Thread: B time: 1544337136852离开同步块
复制代码

如果将Service改成：

class Service {
    public void method() {
        try {
            String anyStr = new String();
            synchronized (anyStr) {
                System.out.println("Thread: " + Thread.currentThread().getName()
                        + " time: " + System.currentTimeMillis() + "进入同步块");
                Thread.sleep(3000);
                System.out.println("Thread: " + Thread.currentThread().getName()
                        + " time: " + System.currentTimeMillis() + "离开同步块");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
复制代码

运行结果为：

Thread: B time: 1544337317933进入同步块
Thread: A time: 1544337317933进入同步块
Thread: A time: 1544337320933离开同步块
Thread: B time: 1544337320933离开同步块
复制代码

是异步进行的，因此此时两个anyStr对象不是同一个对象了。

synchronized代码块的“脏读”

同步代码块放在非同步方法中进行生命，并不能摆正调用方法的线程的执行同步、顺序性。线程调用方法的顺序是无序的，虽然在同步块中执行的顺序是同步的，这样容易出现“脏读”问题。

class MyOneList{
    private ArrayList list=new ArrayList();
    synchronized public void add(String data){
        list.add(data);
    }
    synchronized public int getSize(){
        return list.size();
    }
}

class MyService{
    public MyOneList add(MyOneList list,String data){
        try {
            System.out.println(Thread.currentThread().getName());
            if(list.getSize()<1){//保证list只有一个元素
                Thread.sleep(2000);
                list.add(data);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return list;
    }
}

class MyThread extends Thread{
    private MyOneList list;
    public MyThread(MyOneList list){
        this.list=list;
    }

    @Override
    public void run() {
        MyService service=new MyService();
        service.add(list,"A");
    }
}

public class Run {
    public static void main(String[] args) throws InterruptedException {
        MyOneList list=new MyOneList();
        MyThread t1=new MyThread(list);
        t1.setName("A");
        t1.start();
        MyThread t2=new MyThread(list);
        t2.setName("B");
        t2.start();
        Thread.sleep(6000);
        System.out.println(list.getSize());

    }
}
复制代码

运行结果：

B
A
2
复制代码

首先可以发现，两个线程打印的顺序是无序的，说明线程的执行时异步的。返回的结果中list的size为2，原因是在add()方法中，list.getSize()这一方法是异步调用的。因此，需要对add()方法进行同步化，修改如下：

class MyService {
    public MyOneList add(MyOneList list, String data) {
        try {
            synchronized (list) {
                System.out.println(Thread.currentThread().getName());
                if (list.getSize() < 1) {//保证list只有一个元素
                    Thread.sleep(2000);
                    list.add(data);
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return list;
    }
}
复制代码

list对象在项目中只有一份实例，且对其进行调用，因此以list参数进行同步处理。结果如下：

A
B
1
复制代码

synchronized(非this对象x)的三个结论

  1. 当多个线程同时执行synchronized(x)同步代码块时是同步的；
  2. 当线程A执行以x为锁的代码块时，其他线程执行x对象中的同步方法时也是同步的；
  3. 当线程A执行以x为锁的代码块时，其他线程执行x对象中的synchronized(this)代码块时也是同步的。

静态synchronized方法与synchronized(class)代码块

关键字synchronized还可以应用在static静态方法上，这样是堆当前的*.java文件对应的Class类加锁。

class Service{
    synchronized public static void printA(){
        try {
            System.out.println("thread: "+Thread.currentThread().getName()+" time: "+System.currentTimeMillis()+" 进入printA方法");
            Thread.sleep(3000);
            System.out.println("thread: "+Thread.currentThread().getName()+" time: "+System.currentTimeMillis()+" 离开printA方法");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    synchronized public static void printB(){
            System.out.println("thread: "+Thread.currentThread().getName()+" time: "+System.currentTimeMillis()+" 进入printB方法");
            System.out.println("thread: "+Thread.currentThread().getName()+" time: "+System.currentTimeMillis()+" 离开printB方法");
    }

    synchronized public  void printC(){
        System.out.println("thread: "+Thread.currentThread().getName()+" time: "+System.currentTimeMillis()+" 进入printC方法");
        System.out.println("thread: "+Thread.currentThread().getName()+" time: "+System.currentTimeMillis()+" 离开printC方法");
    }
}

class ThreadA extends Thread{
    private Service service;
    public ThreadA(Service service){
        this.service=service;
    }
    @Override
    public void run() {
        service.printA();
    }
}

class ThreadB extends Thread{
    private Service service;
    public ThreadB(Service service){
        this.service=service;
    }
    @Override
    public void run() {
        service.printB();
    }
}


class ThreadC extends Thread{
    private Service service;
    public ThreadC(Service service){
        this.service=service;
    }
    @Override
    public void run() {
        service.printC();
    }
}

public class Run {
    public static void main(String[] args) {
        Service service=new Service();
        ThreadA a=new ThreadA(service);
        a.setName("A");
        a.start();
        ThreadB b=new ThreadB(service);
        b.setName("B");
        b.start();
        ThreadC c=new ThreadC(service);
        c.setName("C");
        c.start();
    }
}
复制代码

运行结果：

thread: A time: 1544341920925 进入printA方法
thread: C time: 1544341920925 进入printC方法
thread: C time: 1544341920925 离开printC方法
thread: A time: 1544341923925 离开printA方法
thread: B time: 1544341923925 进入printB方法
thread: B time: 1544341923925 离开printB方法
复制代码

可以看出，A与C并不是同步的，A与B是同步的。原因就是A和B是持有的同一个Class锁，而C持有的是对象锁。

但是，Class锁可以对类的所有对象实例起作用。修改上述的代码，只修改main方法如下：

public class Run {
    public static void main(String[] args) {
        Service service1=new Service();
        Service service2=new Service();
        ThreadA a=new ThreadA(service1);
        a.setName("A");
        a.start();
        ThreadB b=new ThreadB(service2);
        b.setName("B");
        b.start();
    }
}
复制代码

运行结果如下：

thread: A time: 1544342122668 进入printA方法
thread: A time: 1544342125668 离开printA方法
thread: B time: 1544342125668 进入printB方法
thread: B time: 1544342125668 离开printB方法
复制代码

可以看到，线程A和线程B虽然调用的是不同的对象，但是由于二者是Class锁，因此仍然是同步进行的。

synchronized(class)代码块和synchronized static方法的作用是一样的，修改上述的printA()和printB()方法如下：

class Service {
    public static void printA() {
        synchronized (Service.class) {
            try {
                System.out.println("thread: " + Thread.currentThread().getName() + " time: " + System.currentTimeMillis() + " 进入printA方法");
                Thread.sleep(3000);
                System.out.println("thread: " + Thread.currentThread().getName() + " time: " + System.currentTimeMillis() + " 离开printA方法");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    synchronized public static void printB() {
        synchronized (Service.class) {
            System.out.println("thread: " + Thread.currentThread().getName() + " time: " + System.currentTimeMillis() + " 进入printB方法");
            System.out.println("thread: " + Thread.currentThread().getName() + " time: " + System.currentTimeMillis() + " 离开printB方法");
        }
    }
}
复制代码

Run类和刚刚修改后的两个不同的Service对象一样，运行结果为：

thread: A time: 1544342263970 进入printA方法
thread: A time: 1544342266970 离开printA方法
thread: B time: 1544342266970 进入printB方法
thread: B time: 1544342266970 离开printB方法
复制代码

可以看到效果是一样的。

synchronized(string)同步代码块

在JVM中，具有String常量池缓存功能。在将synchronized(string)使用时，需要注意常量池带来的一些例外。在大多数情况下，同步代码块不推荐使用String作为锁对象，而改用其他，比如new Object()，它不放入缓存中。

多线程的死锁

死锁的场景一般是：线程 A 和线程 B 都在互相等待对方释放锁，或者是其中某个线程在释放锁的时候出现异常如死循环之类的。这时就会导致系统不可用。

常用的解决方案如下：

  • 尽量一个线程只获取一个锁。
  • 一个线程只占用一个资源。
  • 尝试使用定时锁，至少能保证锁最终会被释放。
内置类与静态内置类

判断是否同步的方法是一样的，都是判断是否是同一个对象为锁。

锁对象的改变

如果锁对象本身改变了（如String从“a”变成了“b”），则改变前和改变后，线程的锁不一样，是异步的。但是如果锁的属性改变了，但是锁对象本身没变，则仍然是同步的。

参考资料

weixin_33936401
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
两个线程，轮流有序执行的两种方法
qq_33881799的博客
11-22 3880
两个线程的任务都是打印1到1000的数据，要求线程1打印一次后线程2继续打印，实现轮流打印方法1：使用interrupt()和sleep()协调使用，一个打印完成后sleep(),并且interrupt另一个线程的睡眠，同时让自己睡眠，循环1000次即可方法2：通过公共锁object，配合wait()和notify()/notifyAll()方法，睡眠自己，唤醒另一线程，循环1000次public
Java编程思想重点笔记(Java开发必看).pdf
11-29
- **Java简介**：Java是由Sun Microsystems公司开发的一种跨平台、面向对象的编程语言，现由甲骨文公司维护。 - **类与对象**：Java是面向对象的语言，一切皆为对象。类是创建对象的模板，对象则是类的实例。 - *...
线程通信之两个线程交替打印数字和字母
u011345756的专栏
12-15 878
等待通知是一个经典的范式，该范式分为两部分，分别是针对等待方（消费者）和通知方（生产者）。 等待方遵循如下原则： 1）获取对象的锁 2）如果条件不满足，调用wait方法，被通知后仍要检查条件 3）条件满足执行对应逻辑 伪代码如下： synchronized（对象）{ while(条件不满足){ 对象.wait(); ...
java 多线程顺序打印_Java多个线程顺序打印数字
weixin_29913663的博客
02-13 395
要求启动N个线程, 这N个线程要不间断按顺序打印数字1-N. 将问题简化为3个线程无限循环打印1到3方法一: 使用synchronized三个线程无序竞争同步锁, 如果遇上的是自己的数字, 就打印. 这种方式会浪费大量的循环public class TestSequential1 {private volatile int pos = 1;private volatile int count = ...
多线程轮流打印数字
neverSaynever_的博客
05-16 193
1、使用 synchronized配合 notify和 wait实现 其他相关学习：synchronized 和 volatile 区别 1) 两个线程轮流打印数字 num1 = [1,3,5,7] nums2= [2,4,6,8] 输出结果：1，2，3，4，5，6，7，8 /* *两个线程使用锁打印数组 */ public class PrintNumberByTwoThread{ private Object obj = new Object(); int[] num1
【Java多线程】Java 多个线程交替打印数字
code_garden
03-17 1644
两个线程交替打印数字 /** * 两个线程顺序交替打印数字 */ public class Test5 implements Runnable { int i = 0; @Override public void run() { synchronized (this){ while (i < 200) { ...
【java多线程】线程同步问题：用同步代码块、同步方法和重入锁实现线程同步
m0_65277261的博客
03-26 1306
同步是执行或调用一个方法时，每次都需要拿到对应的结果才会继续往后执行；异步与同步相反，它会在执行或调用一个方法后就继续往后执行，不会等待获取执行结果。二者的区别就是处理请求发出后，是否需要等待请求结果，再去继续执行其他操作。
java互斥和同步_java的多线程同步互斥:synchronized的乱用
weixin_28949937的博客
02-26 72
java的多线程同步互斥:synchronized的乱用在java的多线程同步互斥处理中,synchronized是别不可少的东西.但是如果不清晰的编程的话,也就是乱用synchronized的话,死锁的发生就是离你很近的话题了.在前面的一个维护中就发现一个死锁的bug.究其原因是开发者没有真正明白多线程的同步互斥,没有意识到死锁的发生,或者说自己认为写的代码不会发生死锁.死锁的发生一般并不是很容...
【Java多线程】之二：synchronized详解
andybbc的博客
01-27 1161
关于synchronized的总结如下：  1、synchronized关键字的作用域有二种：  1）是某个对象实例内，synchronized aMethod(){}可以防止多个线程同时访问这个对象的synchronized方法（如果一个对象有多个synchronized方法，只要一个线程访问了其中的一个synchronized方法，其它线程不能同时访问这个对象中任何一个synchroniz
Java编程思想笔记(全)
06-14
### Java编程思想笔记知识点概述 #### 第 1 章 对象导论 在这一章节中，主要介绍了Java中的基本概念——对象。对象是面向对象编程的核心，它封装了数据和行为。本章首先解释了对象的概念，接着讨论了如何创建对象...
计算机Java核心编程笔记
11-04
它的主要特点是平台独立、对象编程、分布式、多线程等。 二、Java标识符和关键字 Java中的标识符是为方法、变量或其他用户定义项所定义的名称。标识符可以有一个或多个字符。Java语言中，标识符的构成规则是：...
Java多线程问题及处理笔记.doc
10-11
Java多线程编程是开发高性能应用的关键技术之一。在Java中，多线程可以提高程序的执行效率，尤其是在处理并发任务时。然而，多线程同时也带来了一些问题，如线程安全、死锁和线程优先级等。下面将详细讨论这些知识点...
Java避坑指南：Java高手笔记代码篇.rar
02-25
3. **多线程编程**：Java提供了丰富的并发工具，如synchronized关键字、volatile变量、ThreadLocal、ExecutorService等。理解和熟练运用这些工具，可以编写出高效、安全的多线程程序。 4. **集合框架**：对...
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
qq_43700885的博客
07-29 628
1.导入hutool的maven依赖。2.复制一下代码执行。
SpringBoot+Vue图书(图书借阅)管理系统-附项目源码与配套文档
最新发布
m0_74283290的博客
08-03 659
本论文阐述了一套先进的图书管理系统的设计与实现，该系统采用Java语言，结合现代Web开发框架和技术，旨在为图书馆提供高效、灵活且用户友好的资源管理解决方案。系统利用Spring Boot框架为核心，整合MyBatis ORM工具，以及MySQL数据库，构建了一个高性能、可扩展的后端服务。前端界面则采用了Vue.js框架，以提供流畅的用户交互体验。论文首先进行了详尽的需求分析，确定了系统的核心功能，包括图书的添加、编辑、删除、查询，读者的注册、登录、个人信息管理，以及图书的借阅、归还、续借流程。
社区养老服务小程序的设计
Karen198的博客
07-31 553
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
Springboot+Websocket+Security+Vue 实现弹幕推送功能
Gemini1995的博客
08-01 491
【代码】Springboot+Websocket+Security+Vue 实现弹幕推送功能。
JavaSE面向对象进阶
qq_45348840的博客
07-30 497
需求：在实际开发中，经常会遇到一些数组使用的工具类;请按照如下要求编写一个数组的工具类：ArrayUtil提供一个工具类方法printArr,用于返回整数数组的内容。返回的字符串格式如：[10,20,50,34,100 ]（只考虑整数数组，且只考虑一维数组)提供这样一个工具方法getAerage,用于返回平均分。（只考虑浮点型数组，且只考虑一维数组)定义一个测试类TestDemo,调用该工具类的工具方法，并返回结果。// 私有化构造方法// 定义静态方法，方便调用。i++) {
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 382
1.导入hutool的maven依赖。2.直接复制一下代码运行。
Java初学者编程笔记：关键字与语法要点
这份笔记中还提到了一些其他概念，如循环（如`for`和`while`）、访问控制（`private`, `public`, `protected`）、异常处理（`try-catch-finally`）、继承和接口（`extends`, `implements`）、多线程（`synchronized`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值