synchronized关键字(三)

最新推荐文章于 2024-03-03 21:02:09 发布
最新推荐文章于 2024-03-03 21:02:09 发布
阅读量450 收藏
点赞数
分类专栏： Java多线程 文章标签： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/babycan5/article/details/83352344
版权
一、三个结论

对于 synchronized(非 this 对象 x)

  1. 当多个线程同时执行 synchronized(x){} 同步代码块时呈现同步效果
  2. 当其他线程执行 x 对象中 synchronized 同步方法时呈同步效果
  3. 当其他线程执行 x 对象方法里面的 synchronized(this) 代码块时也呈同步效果

需要说的是，虽然有三点，都是本质都是一样的，即每个线程拥有相同的对象锁，可以看一下第2个结论的例子

class MyObject {
	//synchronized 同步方法
    synchronized public void speedPrintString() {
        System.out.println(Thread.currentThread().getName()
                + " speedPrintString begin " + System.currentTimeMillis());
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()
                + " speedPrintString end " + System.currentTimeMillis());
    }

}

class Service1 {

    public void testMethod(MyObject object) {

        synchronized (object) {
            try {
                System.out.println(Thread.currentThread().getName() + " testMethod begin "
                        + System.currentTimeMillis());
                Thread.sleep(3000);
                System.out.println(Thread.currentThread().getName() + " testMethod end "
                        + System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

class ThreadB1 extends Thread {

    private MyObject object;

    public ThreadB1(MyObject object) {
        this.object = object;
    }

    @Override
    public void run() {
        //线程 B 执行 synchronized 同步方法
        object.speedPrintString();
    }

}

public class ThreadA1 extends Thread {

    private Service1 service1;
    private MyObject object;

    public ThreadA1(Service1 service1, MyObject object) {
        this.service1 = service1;
        this.object = object;
    }

    @Override
    public void run() {
        //线程 A 执行 testMethod 中的同步方法块
        service1.testMethod(object);
    }

    public static void main(String[] args) throws InterruptedException {
        Service1 service1 = new Service1();
        MyObject object = new MyObject();

        ThreadA1 threadA1 = new ThreadA1(service1, object);
        threadA1.setName("AAA");
        threadA1.start();

        Thread.sleep(2000);

        ThreadB1 threadB1 = new ThreadB1(object);
        threadB1.setName("BBB");
        threadB1.start();
    }

}

结果是：

AAA testMethod begin 1540385682634
AAA testMethod end 1540385685634
BBB speedPrintString begin 1540385685634
BBB speedPrintString end 1540385687634

结果是同步执行的。同步方法块持有的是 object 对象锁，同步方法也是持有的 object 锁，这时因为两者都是对同一个 object 对象进行处理的。

第三个结论和第二个一样，不会是把同步方法变成了同步代码块，这里不加赘述

二、静态同步方法和synchronized(class)

synchronized 还可以作用于 static 静态方法上，表示对当前的 Class 类进行持锁

class Service3 {

    synchronized public static void printA() {
        try {
            System.out.println(Thread.currentThread().getName() + " 在 "
                    + System.currentTimeMillis() + " 进入 printA ");
            Thread.sleep(2000);
            System.out.println(Thread.currentThread().getName() + " 在 "
                    + System.currentTimeMillis() + " 离开 printA ");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    synchronized public static void printB() {
        try {
            System.out.println(Thread.currentThread().getName() + " 在 "
                    + System.currentTimeMillis() + " 进入 printB");
            Thread.sleep(3000);
            System.out.println(Thread.currentThread().getName() + " 在 "
                    + System.currentTimeMillis() + " 离开 printB");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    synchronized public void printC() {
        try {
            System.out.println(Thread.currentThread().getName() + " 在 "
                    + System.currentTimeMillis() + " 进入 printC");
            Thread.sleep(4000);
            System.out.println(Thread.currentThread().getName() + " 在 "
                    + System.currentTimeMillis() + " 离开 printC");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

class ThreadB3 extends Thread{

    private Service3 service3;

    public ThreadB3(Service3 service3) {
        this.service3 = service3;
    }

    @Override
    public void run() {
        //调用 static 方法
        service3.printB();
    }
}

class ThreadC3 extends Thread {

    private Service3 service3;

    public ThreadC3(Service3 service3) {
        this.service3 = service3;
    }

    @Override
    public void run() {
        //调用非 static 方法
        service3.printC();
    }
}

public class ThreadA3 extends Thread {

    private Service3 service3;

    public ThreadA3(Service3 service3) {
        this.service3 = service3;
    }

    @Override
    public void run() {
        //调用 static 方法
        service3.printA();
    }

    public static void main(String[] args) {
        Service3 service3 = new Service3();
        ThreadA3 threadA3 = new ThreadA3(service3);
        threadA3.setName("AAA");
        threadA3.start();

        ThreadB3 threadB3 = new ThreadB3(service3);
        threadB3.setName("BBB");
        threadB3.start();

        ThreadC3 threadC3 = new ThreadC3(service3);
        threadC3.setName("CCC");
        threadC3.start();
    }

}

结果是：

AAA 在 1540386724917 进入 printA 
CCC 在 1540386724917 进入 printC
AAA 在 1540386726917 离开 printA 
BBB 在 1540386726917 进入 printB
CCC 在 1540386728917 离开 printC
BBB 在 1540386729931 离开 printB

从结果看出，线程 AAA 和线程 BBB 是同步执行的，而线程 CCC 和他们两个都是异步执行的。因为线程 AAA 和线程 BBB 调用的是同步 static 方法，因此他们俩持有的是类锁，线程 CCC 调用的是同步非 static 方法，因此他持有的是对象锁，持有的锁不同是异步的主要原因

因为线程 AAA 和线程 BBB 持有的是类锁，因此，只要调用的是同一个类，就算调用类的不同的对象，也是同步执行的

//使用两个线程持有相同类锁的情况下调用不同的对象
public static void main(String[] args) {
    Service3 service3 = new Service3();
    Service3 service31 = new Service3();
    ThreadA3 threadA3 = new ThreadA3(service3);
    threadA3.setName("AAA");
    threadA3.start();

    ThreadB3 threadB3 = new ThreadB3(service31);
    threadB3.setName("BBB");
    threadB3.start();
}

结果为：

AAA 在 1540387705925 进入 printA 
AAA 在 1540387707926 离开 printA 
BBB 在 1540387707926 进入 printB
BBB 在 1540387710927 离开 printB

可见类锁对类的所有实例起作用

同步 synchronized(class) 代码块

同步 synchronized(this) 代码块的作用和 synchronized static 方法的作用一样，都是持有类的锁

class Service4 {

    public void printA() {
        synchronized (Service4.class) {
            try {
                System.out.println(Thread.currentThread().getName() + " 在 "
                        + System.currentTimeMillis() + " 进入 printA");
                Thread.sleep(2000);
                System.out.println(Thread.currentThread().getName() + " 在 "
                        + System.currentTimeMillis() + " 离开 printA");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public void printB() {
        synchronized (Service4.class) {
            System.out.println(Thread.currentThread().getName() + " 在 "
                    + System.currentTimeMillis() + "进入 printB");
            System.out.println(Thread.currentThread().getName() + " 在 "
                    + System.currentTimeMillis() + "离开 printB");
        }
    }

}

class ThreadB4 extends Thread{

    private Service4 service4;

    public ThreadB4(Service4 service4) {
        this.service4 = service4;
    }

    @Override
    public void run() {
        service4.printA();
    }
}

public class ThreadA4 extends Thread {

    private Service4 service4;

    public ThreadA4(Service4 service4) {
        this.service4 = service4;
    }

    @Override
    public void run() {
        service4.printB();
    }

    public static void main(String[] args) {
        Service4 service4 = new Service4();
        Service4 service41 = new Service4();
        ThreadA4 threadA4 = new ThreadA4(service4);
        threadA4.setName("AAA");
        threadA4.start();

        ThreadB4 threadB4 = new ThreadB4(service41);
        threadB4.setName("BBB");
        threadB4.start();
    }

}

结果是：

AAA 在 1540387998044进入 printB
AAA 在 1540387998045离开 printB
BBB 在 1540387998045 进入 printA
BBB 在 1540388000045 离开 printA

三、String常量池带来的问题

在使用 synchronized(非 this 对象 x) 的时候，对象 x 最好不要设置成 String 类型的，这时由于 String 有常量池的问题，如果有这样的方法

public void print(String str) {
    synchronized (str) {
        while(true) {
            System.out.println(Thread.currentThread().getName());
        }
    }
}

那么当我们在多个线程中运行这个方法，并且以下两个 String 类型参数 a 和 b 时

String a = "A"；
String b = "A";

因为 String 常量池的问题，所以对象 a 是 == 对象 b 的，当我们用不同的线程调用 print 方法并且分别传入参数 a 和 b 时，那么这两个线程持有的就是相同的对象锁，造成一个线程在执行，而一个线程用于在等待的情况，结果类似这样：

Thread-0 AAAA
Thread-0 AAAA
Thread-0 AAAA
Thread-0 AAAA
...

所以，大多数情况下，同步 synchronized 代码块都不使用 String 作为锁对象，而使用其他的，比如 Object 等

四、死锁

因为不同的线程都在等待根本不可能被释放的锁，而导致所有的任务都无法继续完成，这个就是死锁

public class DealThread implements Runnable {

    public String username;
    public Object lock1 = new Object();
    public Object lock2 = new Object();

    public void setFlag(String username) {
        this.username = username;
    }

    @Override
    public void run() {
        if (username.equals("a")) {
            synchronized (lock1) {
                try {
                    System.out.println("username = " + username);
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                synchronized (lock2) {
                    System.out.println("按 lock1 -> lock2 代码顺序执行");
                }
            }
        }

        if (username.equals("b")) {
            synchronized (lock2) {
                try {
                    System.out.println("username = " + username);
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                synchronized (lock1) {
                    System.out.println("按 lock2 -> lock1 代码顺序执行");
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        DealThread dealThread = new DealThread();
        dealThread.setFlag("a");

        Thread thread = new Thread(dealThread);
        thread.start();

        Thread.sleep(2000);

        dealThread.setFlag("b");
        Thread thread1 = new Thread(dealThread);
        thread1.start();
    }
}

结果是：

username = a
username = b

可以看到，此时两个线程发生了死锁，具体是这样的：

  1. 线程 A 先持有对象 lock1 的锁，然后在持有 lock1 锁的时候又想去申请 lock2 的锁，此时他还没有释放 lock1 的锁；
  2. 线程 B 先持有对象 lock2 的锁，然后在持有 lock2 锁的时候又想去申请 lock1 的锁，此时他还没有释放 lock2 的锁；
  3. 两方都握有自己的锁不放弃，而又同时申请另一方的锁，所以，此时就造成了死锁

虽然这个实验实验 synchronized 嵌套的代码结构来实现死锁，其实不用嵌套的 synchronized 代码结构也会出现死锁，与嵌套不嵌套没有关系。只要互相等待对方释放锁就有可能出现死锁

五、参考

《Java多线程编程核心技术》

EclipseO2
关注
专栏目录
java 锁 null_synchronized加锁的对象如果被置为null
weixin_32309879的博客
02-25 1343
代码public class MonitorNullDemo implements Runnable {private Object object = new Object();@Overridepublic void run() {synchronized (object) {System.out.println(Thread.currentThread().getName() + "开始执行，...
synchronized(obj)
uusad的专栏
08-24 3498
一个对象一把锁，不管锁这个对象的哪个引用，均是同一把锁。 基本原则是： 1.在synchronized块中不要改变该锁定对象在堆中内存的位置（貌似是根据对象的地址进行锁定） 2.synchronized不能锁null。 例子1： public class SynTest { public static String obj; public static void main(S
Synchronized
mulanlong的博客
11-27 3898
参考：https://blog.csdn.net/luoweifu/article/details/46613015 1.synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种：  （1） 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；  （2）修饰一个方法，被修饰的方法称为同步方法，其作用的范围...
synchronized用法详解
最新发布
qq_43842093的博客
03-03 4088
synchronized 是 Java 中的关键字，是一种同步锁。主要应用于多线程环境下保证线程的安全性。A. 无论synchronized关键字加在方法上还是对象上，如果它作用的对象是非静态的，则它取得的锁是对象；如果synchronized作用的对象是一个静态方法或一个类，则它取得的锁是对类，该类所有的对象同一把锁。B. 每个对象只有一个锁（lock）与之相关联，谁拿到这个锁谁就可以运行它所控制的那段代码。C. 实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。
线程同步机制synchronized
Avices
08-09 362
线程同步机制synchronized 如果有一部分代码必须是线程排队的，不能并发。一个线程把这里的代码全部执行结束之后，另一个线程才能进来。需要使用线程同步机制 线程同步机制的语法是： 使用同步代码块的方式，这种方式比较灵活。修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象； synchronized(线程共享对象){ // 线程同步代码块。 } 在实例方法上使用synchronized，例如： synchronize
举例讲解Java中synchronized关键字的用法
09-02
在Java编程语言中，`synchronized`关键字是一个非常重要的概念，它主要用于多线程环境中的线程同步，确保共享资源的正确访问，防止数据不一致性。以下是对`synchronized`关键字使用方法的详细讲解： 1. **修饰实例...
synchronized 关键字详解
TanaStudy的博客
04-07 7069
synchronized 关键字1. synchronized 关键字的三种使用方法1.1. 修饰实例方法2.2. 修饰静态方法3.3. 修饰代码块2. 双重检验锁方式实现单例模式3. 构造方法可以使用 synchronized 关键字修饰么？4. JDK1.6 之后的 synchronized 关键字底层做了哪些优化？5. synchronized 和 ReentrantLock 的区别6. synchronized 关键字与Lock的区别 synchronized 关键字解决的是多个线程之间访问资源的同
synchronized关键字
一切有为法，如梦亦如幻，如露亦如电，应作如是观。
10-23 237
1.Synchronized关键字概述 synchronized关键字解决的是多个线程之间访问资源的同步性，synchronized关键字可以保证被它修饰的方法或者代码块在任意时刻只能有一个线程执行。 另外，在 Java 早期版本中，synchronized属于重量级锁，效率低下。 为什么呢？ 因为监视器锁（monitor）是依赖于底层的操作系统的Mutex Lock来实现的，Java 的线程是映射到操作系统的原生线程之上的。如果要挂起或者唤醒一个线程，都需要操作系统帮忙完成，而...
Java synchronized关键字使用方式及特性解析
08-25
需要注意的是，synchronized关键字的使用需要遵守一定的原则，例如避免使用synchronized关键字在循环语句中，以免出现死锁等问题。此外，synchronized关键字也可以与其他线程同步工具结合使用，以实现更复杂的线程...
Java synchronized关键字和Lock接口实现原理
08-25
Java synchronized关键字和Lock接口实现原理 Java 中的 synchronized 关键字和 Lock 接口是两种常用的线程同步机制，它们都可以用来解决并发问题。下面我们将详细介绍 synchronized 关键字和 Lock 接口的实现原理。...
synchronized关键字(一)
NULL的博客
10-21 548
一、线程安全和不安全 非线程安全：在多个线程对同一个对象的实例变量进行并发访问时会出现值被更改、值不同步的情况 线程安全：获得的实例变量的值是经过同步处理的，按照顺序执行，不会出现脏读情况 举个例子：5个销售员， 卖同一堆货物，每个销售员在卖出一个货品后，并不是立即知道当前货物剩余数量的，因为在他卖出的同时，可能其他销售员已经卖出好几个货品了，如果这个时候就减1，那么就会产生数据的不同步，可能...
并发编程-synchronized详解
null_zhouximin的博客
01-27 344
并发编程-synchronized详解synchronized原理详解Monitor监视器锁对象的内存布局锁的膨胀升级过程（JDK1.5后的优化）二级目录三级目录 synchronized原理详解 synchronized底层原理 synchronized是基于JVM 内置锁实现，通过 内部对象Monitor(监视器锁)实现，基于进入与退出Monitor对象实现方法与代码块同步，监视器锁的实现依赖底层操作系统的Mutex lock（互斥锁）实现，它是一个重量级锁性能较低。当然，JVM内置锁在1.5之后版
Java synchronized(this)与synchronized(object)的区别
李岳锋的专栏
07-08 9471
class Test{ private Object object = new Object(); public void print(){ synchronized (object){ System.out.println("xxxx"); } } } class Test{ public void print(){ synchronized (this){ System.
JVM 内置锁 synchronized 的几种状态概述
yangjnsjbad的博客
01-22 193
内置锁使用 通常我们说的 java 内置锁默认都是指的 JVM 给我们提供的 synchronized 关键字实现的锁。 下面是一个简单的例子： public class SynchronizedVariableTest1 { public static void main(String[] args) throws InterruptedException { SynchronizedVariableTest1 test = new SynchronizedVariable
synchronized(object)
luzhensmart的专栏
08-08 2443
package test.thread; import java.io.IOException; import org.junit.Test; /* * 测试线程锁 */ public class TestBlock { public static void main(String[] args) { /* ...
深入理解synchronized
我的
10-24 224
synchronized同步方法 在java开发中synchronized可以在方法上声明，如果方法上有synchronized关键字就说明该方法是同步方法，在调用该方法的时候回自动加锁，使得其他需要调用该方法的线程等待。简单的说synchronized方法时按照顺序执行的 在这里先说一下变量的安全问题，据我了解方法的局部变量为线程安全的，因为每次调用该方法时都会生成一个变量，所以不存在不同线程使...
synchronized同步语句块（三）
飞少fly的博客
05-23 1067
用关键字synchronized声明的方法在是存在弊端的，在业务场景上来说比如一个线程执行很长时间的任务，那么另外一个线程只能等待。这样的情况下可以使用synchronized同步语句块来解决，synchronized方法是对当前的对象进行枷锁，而synchronized代码块是对某一个对象进行枷锁。...
synchronized的几种加锁方式
热门推荐
x1107761900的博客
03-21 1万+
1、修饰普通方法（锁住的是当前实例对象） 同一个实例调用会阻塞 不同实例调用不会阻塞 public class SynchronizedTest { //锁住了本类的实例对象 public synchronized void test1() { try { logger.info(Thread.currentThread().getName...
CountDownLatch 门闩
快乐的小三菊的博客
06-03 457
CountDownLatch 的使用方式
synchronized关键字在使⽤层⾯的理解 synchronized关键字在字节码中的体现 synchronized关键字在JVM中的实现 synchronized关键字在硬件⽅⾯的实现
06-10
1. synchronized关键字在使用层面的理解 synchronized关键字是Java中用来实现线程同步的关键字，可以修饰方法和代码块。当线程访问被synchronized修饰的方法或代码块时，需要获取对象的锁，如果该锁已被其他线程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值