多线程之synchronized同步语句块(6)

最新推荐文章于 2024-07-24 21:47:59 发布
最新推荐文章于 2024-07-24 21:47:59 发布
阅读量120 收藏
点赞数
文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_27581753/article/details/105991279
版权

1.内置类和静态内置类

关键字synchronized的知识点还涉及内置类的使用。先来看一下简单的内置类测试。

package test;

/**
 * @Author LiBinquan
 */
public class PublicClass {
    private String userName;
    private String passWord;
    class PrivateClass {
        private String age;
        private String address;

        public String getAge() {
            return age;
        }

        public void setAge(String age) {
            this.age = age;
        }

        public String getAddress() {
            return address;
        }

        public void setAddress(String address) {
            this.address = address;
        }
        public void printPublicProperty(){
            System.out.println(userName + "  "+passWord);
        }
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getPassWord() {
        return passWord;
    }

    public void setPassWord(String passWord) {
        this.passWord = passWord;
    }
}

运行类：

package test;

/**
 * @Author LiBinquan
 */
public class Run {
    public static void main(String[] args) throws InterruptedException {
        PublicClass publicClass = new PublicClass();
        publicClass.setUserName("AA");
        publicClass.setPassWord("aaa");
        System.out.println(publicClass.getUserName() + "  "+publicClass.getPassWord());
        PublicClass.PrivateClass privateClass = publicClass.new PrivateClass();
        privateClass.setAge("13");
        privateClass.setAddress("addressValue");
        System.out.println(privateClass.getAge()+" "+privateClass.getAddress());
    }
}

输出：
在这里插入图片描述
如果PublicClass.java类和Run.java类不在同一个包中，则需要将PrivateClass内置声明public公开的。测试代码如下：

package test;

/**
 * @Author LiBinquan
 */
public class PublicClass {
    static private String userName;
    static private String passWord;
    static class PrivateClass {
        private String age;
        private String address;

        public String getAge() {
            return age;
        }

        public void setAge(String age) {
            this.age = age;
        }

        public String getAddress() {
            return address;
        }

        public void setAddress(String address) {
            this.address = address;
        }
        public void printPublicProperty(){
            System.out.println(userName + "  "+passWord);
        }
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getPassWord() {
        return passWord;
    }

    public void setPassWord(String passWord) {
        this.passWord = passWord;
    }
}

运行类：

package test;

/**
 * @Author LiBinquan
 */
public class Run {
    public static void main(String[] args) throws InterruptedException {
        PublicClass publicClass = new PublicClass();
        publicClass.setUserName("AA");
        publicClass.setPassWord("aaa");
        System.out.println(publicClass.getUserName() + "  "+publicClass.getPassWord());
        PublicClass.PrivateClass privateClass = new PublicClass.PrivateClass();
        privateClass.setAge("13");
        privateClass.setAddress("addressValue");
        System.out.println(privateClass.getAge()+" "+privateClass.getAddress());
    }
}

输出：
在这里插入图片描述

接下来做几个测试：
1.内置类中有2个同步方法，但使用的却是不同的锁，打印的结果也是异步。

package test;

/**
 * @Author LiBinquan
 */
public class OutClass {
    static class Inner{
        public void method1(){
            synchronized ("锁1"){
                for (int i = 0; i < 10; i++) {
                    System.out.println(Thread.currentThread().getName()+" i = "+i);
                    try{
                        Thread.sleep(100);
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }
                }
            }
        }
        public synchronized void method2(){
            for (int i = 0; i < 20; i++) {
                System.out.println(Thread.currentThread().getName()+" i = "+i);
                try{
                    Thread.sleep(100);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
        }
    }
}

运行类：

package test;

/**
 * @Author LiBinquan
 */
public class Run {
    public static void main(String[] args) throws InterruptedException {
        final OutClass.Inner inner = new OutClass.Inner();
        Thread t1 = new Thread(new Runnable(){
            public void run (){
                inner.method1();
            }
        },"A");
        Thread t2 = new Thread(new Runnable(){
            public void run (){
                inner.method2();
            }
        },"B");
        t1.start();
        t2.start();
    }
}

输出：
在这里插入图片描述
由输出可得，持有不同的“对象监视器”，所以打印结果就是无序的。

2.同步代码块(class2)对class2上锁后，其他线程只能以同步的方式调式用class2中的静态同步方法。

package test;

/**
 * @Author LiBinquan
 */
public class OutClass {
    static class Inner1{
        public void method1(Inner2 class2){
            String threadName = Thread.currentThread().getName();
            synchronized (class2){
                System.out.println(threadName +"进入 Inner1 类中的 method1 方法");
                for (int i = 0; i < 10; i++) {
                    System.out.println("i = "+i);
                    try{
                        Thread.sleep(100);
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }
                }
                System.out.println(threadName +"离开 Inner1 类中的 method1 方法");
            }
        }
        public synchronized void method2(){
            String threadName = Thread.currentThread().getName();
            System.out.println(threadName +"进入 Inner1 类中的 method2 方法");
            for (int k = 0; k < 20; k++) {
                System.out.println(" k = "+k);
                try{
                    Thread.sleep(100);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
            System.out.println(threadName +"离开 Inner1 类中 method2 方法");
        }
    }
    static class Inner2{
        public synchronized void method1(){
            String threadName = Thread.currentThread().getName();
            System.out.println(threadName + "进入 Inner2 类中的method1 方法");
            for (int i = 0; i < 10; i++) {
                System.out.println(" m = "+i);
                try{
                    Thread.sleep(100);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
            System.out.println(threadName + "离开入 Inner2 类中的method1 方法");
        }
    }
}

运行类：

package test;

/**
 * @Author LiBinquan
 */
public class Run {
    public static void main(String[] args) throws InterruptedException {
        final OutClass.Inner1 inner1 = new OutClass.Inner1();
        final OutClass.Inner2 inner2 = new OutClass.Inner2();
        Thread t1 = new Thread(new Runnable(){
            public void run (){
                inner1.method1(inner2);
            }
        },"A");
        Thread t2 = new Thread(new Runnable(){
            public void run (){
                inner1.method2();
            }
        },"B");
        Thread t3 = new Thread(new Runnable(){
            public void run (){
                inner2.method1();
            }
        },"C");
        t1.start();
        t2.start();
        t3.start();
    }
}

输出：
在这里插入图片描述

2.锁对象的改变

在将任何数据类型作为同步锁时，需要注意的是，是否有多个线程同时持有锁对象，如果同时持有相同的锁对象，则这些线程之间就是同步的；如果分别获得锁对象，这些线程就是异步的。

package test;

/**
 * @Author LiBinquan
 */
public class MyService {
    private String lock = "123";
    public void testMethod(){
        try{
            synchronized (lock){
                System.out.println(Thread.currentThread().getName()+" begin "+System.currentTimeMillis());
                lock = "456";
                Thread.sleep(2000);
                System.out.println(Thread.currentThread().getName()+" end   "+System.currentTimeMillis());
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

线程1：

package test;


/**
 * @Author LiBinquan
 */
public class ThreadTest1 extends Thread{

    private MyService service;
    public ThreadTest1(MyService service){
        super();
        this.service = service;
    }
    @Override
    public void run() {
        service.testMethod();
    }
}

线程2：

package test;


/**
 * @Author LiBinquan
 */
public class ThreadTest2 extends Thread{
    private MyService service;
    public ThreadTest2(MyService service){
        super();
        this.service = service;
    }
    @Override
    public void run() {
        service.testMethod();
    }
}

运行类：

package test;

/**
 * @Author LiBinquan
 */
public class Run {
    public static void main(String[] args) throws InterruptedException {
        MyService service = new MyService();
        ThreadTest1 a = new ThreadTest1(service);
        a.setName("A");
        ThreadTest2 b = new ThreadTest2(service);
        b.setName("B");
        a.start();
        Thread.sleep(50);
        b.start();
    }
}

输出：
在这里插入图片描述
因为50毫秒过后线程B取得的锁是“456”。
去掉Thread.sleep(50)，代码如下：

package test;

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

输出：
在这里插入图片描述
这时线程1和线程2的锁都是“123”，虽然将随改成了“456”，但是结果还是同步的，因为1和2共同争抢的锁是“123”。
注意：只要对象不变，及时对象的属性被改变，运行的结果还是同步。测试代码如下，

package test;

/**
 * @Author LiBinquan
 */
public class Service {
    public void serviceMethodA(User user){
        synchronized (user){
            try{
                System.out.println(Thread.currentThread().getName());
                user.setUserName("abc");
                Thread.sleep(3000);
                System.out.println("end time = "+System.currentTimeMillis());
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}

线程1：

package test;


/**
 * @Author LiBinquan
 */
public class ThreadTest1 extends Thread{

    private Service service;
    private User user;
    public ThreadTest1(Service service,User user){
        super();
        this.service = service;
        this.user = user;
    }
    @Override
    public void run() {
        service.serviceMethodA(user);
    }
}

线程2：

package test;


/**
 * @Author LiBinquan
 */
public class ThreadTest2 extends Thread{
    private Service service;
    private User user;
    public ThreadTest2(Service service,User user){
        super();
        this.service = service;
        this.user = user;
    }
    @Override
    public void run() {
        service.serviceMethodA(user);
    }
}

运行类：

package test;

/**
 * @Author LiBinquan
 */
public class Run {
    public static void main(String[] args) throws InterruptedException {
        try{
            Service service = new Service();
            User user = new User();
            ThreadTest1 t1 = new ThreadTest1(service,user);
            t1.setName("A");
            t1.start();
            Thread.sleep(50);
            ThreadTest2 t2 = new ThreadTest2(service,user);
            t2.setName("B");
            t2.start();
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

输出：
在这里插入图片描述

道墟
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
synchronized用法详解
ganmaotong的博客
06-01 1万+
目录1.线程安全问题2.使用同步机制管理共享数据3.synchronized原理概述3.1 同步代码块的实现原理3.2 同步方法的原理4.synchronized的使用4.1同步代码块 4.2同步普通方法4.3同步静态方法5.synchronized的不可中断性与可重入性5.1 不可中断性5.2 可重入性6.使用synchronized的注意事项6.1注意synchronized同步块的粒度 6.2 对 String 加锁 6.3 对Integer、Long、Short等包装类加锁 线程允许程
多线程（四）线程的同步之同步代码块
hi~隔壁老王的博客
08-19 816
之所以会出现《多线程（四）线程的同步之线程安全问题》文章中的问题，其原因是因为run方法体不具有同步安全性：程序中有两条并发线程在修改Account对象。一个线程进入方法准备减少取钱金额，但是还没减少取钱金额时，另一个线程由于判断金额没有减少，故可以进入取钱方法体中，因而造成余额负数情况出现。 为了解决这个问题，Java的多线程支持引入了同步监视器来解决这个问题，使用同步监视器的同步方法就是同步
synchronized 的 8 种用法，你会几种？
Java技术栈，分享最主流的Java技术
08-28 790
点击关注公众号，Java干货及时送达国内最强微服务框架，没有之一！几乎覆盖 Spring Boot 所有操作！2023全新 Java面试题（2500＋）简介本文将介绍8种同步方法的访问场景，我们来看看这8种情况下，多线程访问同步方法是否还是线程安全的。这些场景是多线程编程中经常遇到的，而且也是面试时高频被问到的问题，所以不管是理论还是实践，这些都是多线程场景必须要掌握的场景。八种使用场景...
【线程 锁】synchronized所有用法汇总(包含this语法)
m0_45406092的博客
11-03 2115
文章目录1. synchronized的用法2. synchronized作用于实例方法2.1 多个线程访问同一个对象的同一个synchronized方法2.2 多个线程访问同一个对象的不同的synchronized方法2.3 一个线程获取了该对象的锁之后，其他线程来访问其他非synchronized实例方法2.4 当多个线程作用于不同的实例对象3. synchronized作用于静态方法4. Synchronized作用于代码块4.1 作用在对象实例上4.1.1 作用在对象实例上例子4.1.2 作用在对象
synchronized同步语句块(二)
u014785687的博客
03-08 415
一、静态同步synchronized方法与synchronized(class)代码块 1、静态同步synchronized方法 关键字synchronized可以应用在static静态方法上，是对当前的java文件对应的Class类进行持锁。public class HasSelfPrivateNum { //对静态方法加锁 public synchronized static vo
24.线程的同步机制-synchronized同步语句-synchronized同步代码块的使用.mp4
04-06
在学习Java过程中，自己收集了很多的Java的学习资料，分享给大家，有需要的欢迎下载，希望对大家有用，一起学习，一起进步。
27.线程的同步机制-synchronized同步语句-synchronized代码块间的同步性.mp4
04-06
在学习Java过程中，自己收集了很多的Java的学习资料，分享给大家，有需要的欢迎下载，希望对大家有用，一起学习，一起进步。
synchronized用法大全实例
06-05
本实例大全将全面解析`synchronized`的使用方式，包括同步方法、同步语句块、类锁和对象锁。 ### 1. 同步方法 同步方法是通过在方法声明前加上`synchronized`关键字实现的。这样，同一时间只有一个线程可以执行该...
25.线程的同步机制-synchronized同步语句-使用同步代码块解决同步方法的弊端.mp4
04-06
在学习Java过程中，自己收集了很多的Java的学习资料，分享给大家，有需要的欢迎下载，希望对大家有用，一起学习，一起进步。
30.线程的同步机制-synchronized同步语句-静态同步synchronized方法与synchronized(class)代码块.mp4
04-06
在学习Java过程中，自己收集了很多的Java的学习资料，分享给大家，有需要的欢迎下载，希望对大家有用，一起学习，一起进步。
Synchronized 详解
斜月&三星
02-11 2015
一、Synchronized 的基本使用 Synchronized 的作用主要有三个： 确保线程互斥的访问同步代码 保证共享变量的修改能够及时可见 有效解决重排序问题 从语法上讲，Synchronized 总共有三种用法： 修饰实例方法，作用于当前对象实例加锁，进入同步代码前要获得当前对象实例的锁。 修饰静态方法，作用于当前类对象加锁，进入同步代码前要获得当前类对象的锁。也就是给当前...
synchronized的4种用法
WJ S的专栏
11-21 1038
原文地址：http://hi.baidu.com/wojiubaibudu/blog/item/a27d671ed654cae6e1fe0b42.html synchronized的4种用法 1.方法声明时使用,放在范围操作符(public等)之后,返回类型声明(void等)之前.即一次只能有一个线程进入该方法,其他线程要想在此时调用该方法,只能排队等候,当前线程(就是在synchroni
synchronized的四种用法
诚的博客
05-07 9126
同步锁 synchronized顾名思义，就是用来进行一些同步工作的，我们常常在多线程的环境中使用到它，实现互斥的效果。 每一个java对象都可以当做一个同步锁，线程进入同步代码块或方法的时候会自动获得该锁，在退出同步代码块或方法时会释放该锁。获得锁的唯一途径就是进入这个锁的保护的同步代码块或方法。这里的同步代码块和同步方法，就是使用synchronized关键字标记的代码块和方法。比如： synchronized (object) { //doSomething... .
Java中Synchronized的四种用法
Isonion的博客
08-24 4431
java中Synchronized的四种用法，修饰代码块、修饰方法、修饰静态方法、修饰类
golang 接口
最新发布
m0_70982551的博客
07-24 815
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
synchronized(5)修饰语句块之：synchronized(XXX.class)
05-25
`synchronized(XXX.class)`是一种类锁，它可以保证同一时刻只有一个...总之，使用`synchronized(XXX.class)`可以保证多线程之间的同步性，但是应该注意避免死锁的情况，并且在使用时应该考虑业务逻辑是否适合使用类锁。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值