Java synchronized关键字

已于 2023-03-27 13:55:27 修改
阅读量176 收藏
点赞数
分类专栏： Java 基础 文章标签： java synchronzied
于 2018-12-03 09:05:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chennai1101/article/details/84745728
版权

1. synchronized关键字

synchronized用于实现同步操作，防止出现脏读，常用于修饰方法和代码块。

2. synchronized同步

当synchronized用于修饰方法时，线程锁的对象是其自身，等同于synchronized(this){}代码块，也等同于synchronized(锁对象){}。

public class ObjectLock {

    public synchronized void methodA() {
        System.out.println(Thread.currentThread().getName() + ": methodA begin");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
        }
        System.out.println(Thread.currentThread().getName() + ": methodA end");
    }

    public void methodB() {
        synchronized (this) {
            System.out.println(Thread.currentThread().getName() + ": methodB begin");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            System.out.println(Thread.currentThread().getName() + ": methodB end");
        }
    }

    public static class ThreadA extends Thread {
        ObjectLock lock;

        ThreadA(ObjectLock lock) {
            this.lock = lock;
            setName("A");
        }

        @Override
        public void run() {
            lock.methodA();
        }
    }

    public static class ThreadB extends Thread {
        ObjectLock lock;

        ThreadB(ObjectLock lock) {
            this.lock = lock;
            setName("B");
        }

        @Override
        public void run() {
            lock.methodB();
        }
    }

    public static class ThreadC extends Thread {
        ObjectLock lock;

        ThreadC(ObjectLock lock) {
            this.lock = lock;
            setName("C");
        }

        @Override
        public void run() {
            synchronized (lock) {
                System.out.println(Thread.currentThread().getName() + ": methodC begin");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                }
                System.out.println(Thread.currentThread().getName() + ": methodC end");
            }	
        }
    }

}

分别调用这三个线程

public static void main(String[] args) {
    ObjectLock lock = new ObjectLock();

    ThreadA threadA = new ThreadA(lock);
    threadA.start();

    ThreadB threadB = new ThreadB(lock);
    threadB.start();

    ThreadC threadC = new ThreadC(lock);
    threadC.start();
}

输出
在这里插入图片描述
对象锁有几个注意点

  • 不同的对象拥有不同的锁，相互之间是不同步的。

  • 同步不具有继承性，子类的覆盖方法需要添加synchronized关键字。

  • 多线程死锁问题，线程ThreadA和ThreadB分别拥有lock1和lock2,当ThreadA在请求lock2和ThreadB在请求lock1时都将形成死锁，导致程序无法继续进行。

    public class DeadLock {

    public static void main(String[] args) {
        DeadLock lock1 = new DeadLock();
        DeadLock lock2 = new DeadLock();

        ThreadA threadA = new ThreadA(lock1, lock2);
        threadA.start();

        ThreadB threadB = new ThreadB(lock1, lock2);
        threadB.start();
    }

    public static class ThreadA extends Thread {
        DeadLock lock1, lock2;

        public ThreadA(DeadLock lock1, DeadLock lock2) {
            this.lock1 = lock1;
            this.lock2 = lock2;
            setName("A");
        }

        @Override
        public void run() {
            synchronized (lock1) {
                System.out.println(Thread.currentThread().getName() + ": methodA begin");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                }

                synchronized (lock2) {
                    System.out.println(Thread.currentThread().getName() + ": methodAA");
                }
                System.out.println(Thread.currentThread().getName() + ": methodA end");
            }
        }
    }

    public static class ThreadB extends Thread {
        DeadLock lock1, lock2;

        public ThreadB(DeadLock lock1, DeadLock lock2) {
            this.lock1 = lock1;
            this.lock2 = lock2;			
            setName("B");
        }

        @Override
        public void run() {
            synchronized (lock2) {
                System.out.println(Thread.currentThread().getName() + ": methodB begin");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                }

                synchronized (lock1) {
                    System.out.println(Thread.currentThread().getName() + ": methodBB");
                }
                System.out.println(Thread.currentThread().getName() + ": methodB end");
            }
        }

    }

}

3. synchronized静态同步

对静态方法添加同步操作，等同于等同于synchronized(对象对应Class类){}代码块。

public class StaticLock {

    public static void main(String[] args) {
        ThreadA threadA = new ThreadA();
        threadA.start();

        ThreadB threadB = new ThreadB();
        threadB.start();
    }

    public synchronized static void methodA() {
        System.out.println(Thread.currentThread().getName() + ": methodA begin");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
        }
        System.out.println(Thread.currentThread().getName() + ": methodA end");
    }

    public static class ThreadA extends Thread {

        ThreadA() {        
            setName("A");
        }

        @Override
        public void run() {
            StaticLock.methodA();
        }
    }

    public static class ThreadB extends Thread {

        ThreadB() {
            setName("B");
        }

        @Override
        public void run() {
            synchronized (StaticLock.class) {
                System.out.println(Thread.currentThread().getName() + ": methodB begin");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                }
                System.out.println(Thread.currentThread().getName() + ": methodB end");
            }
        }
    }
}

输出
在这里插入图片描述

4. synchronized和volatile

  • synchronized解决了多个线程之间访问资源的同步性。
  • volatile增加了变量在多个线程之间的可见性，但不具备同步性，也不支持原子性。

例如SyncLock有一个变量condition，分别在不同线程中修改它

public class SyncLock {

    private boolean condition = true;

    public void methodA() {
        System.out.println(Thread.currentThread().getName() + ": methodA begin");
        while(condition) {
        }
        System.out.println(Thread.currentThread().getName() + ": methodA end");
    }

    public void stopMethodA() {
        condition = false;
    }

    public static class ThreadA extends Thread {
        SyncLock lock;

        ThreadA(SyncLock lock) {
            this.lock = lock;
        }

        @Override
        public void run() {
            lock.methodA();
        }
    }

    public static class ThreadB extends Thread {
        SyncLock lock;

        ThreadB(SyncLock lock) {
            this.lock = lock;
        }

        @Override
        public void run() {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
            }
            lock.stopMethodA();
        }
    }

}

测试代码，

public static void main(String[] args) {
    SyncLock lock = new SyncLock();

    ThreadA threadA = new ThreadA(lock);
    threadA.start();

    ThreadB threadB = new ThreadB(lock);
    threadB.start();
}

methodA()会一直在运行（如果不是，改用-server服务器模式运行），除非使用volatile关键字改变condition的可见性。

private volatile boolean condition = true;

synchronized同样可以使不同线程进入同步方法或同步代码块后，具有可视性。

public void methodA() {
    System.out.println(Thread.currentThread().getName() + ": methodA begin");
    while(condition) {
        synchronized (this) {
        }
    }
    System.out.println(Thread.currentThread().getName() + ": methodA end");
}

相关文章
Java synchronized关键字
Java 关键字strictfp、volatile和transient

假装你是大灰狼
关注
专栏目录
简单了解Java synchronized关键字同步
08-25
Java synchronized关键字同步详解 Java 中的 synchronized 关键字是用于实现线程同步的重要机制。下面我们将详细介绍 synchronized 关键字的使用方法和原理。 synchronized 关键字的作用 synchronized 关键字可以...
Java synchronized关键字使用方式及特性解析
08-25
Java中的synchronized关键字是一种实现锁的方式，它是在JVM层面实现的非公平锁。synchronized关键字可以用于实现线程同步，以下是使用synchronized的四种方式： 1. 作用在方法上，保证了访问同一个对象的同一个方法...
java synchronized关键字的用法
09-02
0; public synchronized void...综上所述，synchronized 关键字是 Java 中实现线程同步的重要手段，它通过加锁机制保证了线程安全。然而，在实际应用中，我们需要根据具体场景选择合适的同步策略，以兼顾性能和正确性。
Java synchronized关键字和Lock接口实现原理
08-25
Java synchronized关键字和Lock接口实现原理 Java 中的 synchronized 关键字和 Lock 接口是两种常用的线程同步机制，它们都可以用来解决并发问题。下面我们将详细介绍 synchronized 关键字和 Lock 接口的实现原理。...
java synchronized关键字原理、自定义一把锁来实现同步等
最新发布
02-19
### Java synchronized 关键字原理与自定义锁实现详解 #### 一、Java synchronized 关键字原理 `synchronized` 是 Java 中的关键字之一，用于实现线程间的同步控制，确保共享资源的安全访问。它主要应用于以下两种...
Java Calendar用法
假装你是大灰狼的专栏
11-12 3439
1. Calendar初始化 Calendar calendar = Calendar.getInstance(); 默认是调用GregorianCalendar实例返回，在GregorianCalendar的构造函数中，设置为当前时间 public GregorianCalendar(TimeZone zone, Locale aLocale) { super(zone, aLocal...
Java Lock对象
假装你是大灰狼的专栏
12-03 3252
1. ReentrantLock类 ReentrantLock可以实现线程之间同步互斥，类似于synchronized同样的效果。 public class ThreadReentrantLock { public static void main(String[] args) { ThreadA threadA = new ThreadA(); for...
Java Thread.wait和Thread.notify方法
假装你是大灰狼的专栏
12-03 2799
1. wait和notify方法 wait方法可以使当前执行代码的线程进行等待，notify方法用来通知哪些等待该对象锁的其它线程。wait和notify方法必须要获得该对象的锁，才能运行，否则会报IllegalMonitorStateException的异常。 try { Object lock = new Object(); synchronized (lock) { ...
Java Thread.sleep方法
假装你是大灰狼的专栏
12-03 2383
1. Thread.sleep方法 sleep方法挂起当前线程，直到一段时间后再次进入等待状态。 public class ThreadSleep extends Thread { @Override public void run() { System.out.println("ThreadSleep begin " + System.currentTimeMi
Java 重载与覆盖
假装你是大灰狼的专栏
11-20 1014
1. 重载与覆盖 重载，提供多个具有相同名字的方法，但是它们具有可以彼此分开的不同签名。 覆盖，将方法的超类实现替代为自己的实现，签名必须相同。 如果返回的类型是引用类型，那么覆盖方法的返回类型可以申明为超类方法返回类型的值类型。 子类可以改变超类方法的访问修饰符，但只能提供更多的访问权限。 覆盖方法可以改变其他的方法修饰符，可以改变synchronized、native和strictfp修饰...
Java 自动资源管理
假装你是大灰狼的专栏
12-13 930
从 Java 7 build 105 版本开始，Java 7 的编译器和运行环境支持新的 try-with-resources 语句，称为 ARM 块(Automatic Resource Management) ，自动资源管理。 原有拷贝文件代码一般都是在finally中关闭。 public void copyFile(String fileInput, String fileOutput) {...
Java Thread.interrupt方法
假装你是大灰狼的专栏
12-03 767
Thread.interrupt()方法 Thread.interrupt()方法不会终止一个正在运行的线程，只是发出一个阻塞状态，调用Thread.isInterrupted()方法可以判断。 public class ThreadInterrupt extends Thread { public void run() { boolean pause = fal...
Java SimpleDateFormat用法
假装你是大灰狼的专栏
11-13 563
1. SimpleDateFormat类 SimpleDateFormat是一个日期格式化类，用来格式化日期。 // 构造方法 public SimpleDateFormat(String pattern) // 格式化 public final String Format(Date date) // 转换 public Date parse(String source)throws Pars...
Java Thread.join方法
假装你是大灰狼的专栏
12-03 556
1. Thread.join方法 join方法会等待指定线程结束，然后才会继续运行。 public class ThreadJoin { public static void main(String[] args) { try { ThreadA threadA = new ThreadA(); threadA.start(...
Java 关键字strictfp、volatile和transient
假装你是大灰狼的专栏
11-20 419
1. strictfp 浮点运算有两种运行模式：严格浮点模式和非严格浮点模式。当我们执行严格浮点运算时，在所有的Java虚拟机实现上运行结果都是精确相等的。 strictfp可以用来修饰类、接口和方法。 当声明一个方法是strictfp时，该方法中的所有代码都会遵循严格限制规则来执行。 当使用是strictfp来修饰类或接口时，其中的所有代码都会在严格模式下执行。 2. volatile Ja...
Java 静态导入
假装你是大灰狼的专栏
12-13 250
利用import static 可以不通过调用包名，直接使用包里的静态方法。 打印代码一般如下 public static void main(String[] args) { System.out.println("Hello World"); } 使用import static后 import static java.lang.System.out; public static voi...
Java 可变参数
假装你是大灰狼的专栏
12-13 244
可变参数适用于参数个数不确定，类型确定的情况，一般把可变参数当做数组处理。 可变参数以...的形式实现。 public void print(int...args) { for (int value : args) { System.out.print(value + " "); } System.out.println(); } 调用print()方法 ...
Java 内部类
假装你是大灰狼的专栏
11-19 207
前言 Java拥有四种内部类：静态内部类，成员内部类，局部内部类和匿名内部类。 1. 静态内部类 静态内部类有static修饰，被声明为外部类的静态成员，它的行为和一般的类是一样的。在接口中的内部类都是静态内部类。静态内部类是外部类的成员，可以访问外部类的所有成员，包括私有成员。 public class Super { private int iValue = 1; publi...
Java synchronized关键字深度解析
"本文详细解析了Java中的`synchronized`关键字，它是Java实现线程同步的重要机制。通过使用`synchronized`，可以确保多线程环境下的数据一致性与安全性。它可应用于对象方法、静态方法以及代码块，确保同一时间只有...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值