synchronized

最新推荐文章于 2024-06-19 09:50:23 发布
最新推荐文章于 2024-06-19 09:50:23 发布
阅读量143 收藏 1
点赞数
分类专栏： JAVA系列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sunshunli/article/details/116127699
版权

一：synchronized 引入

在学习知识前，我们先来看一个现象：

package synchronizedlearn;

/**
 * 两个线程同时i++，最后结果会比预计的少
 * 原因：
 * i++: 看上去是一个操作，实际上是三个操作
 * 1 读取 i 的数值
 * 2 将 i 加 1
 * 3 将 i 的值写到内存
 * ------------------------------------------------
 * 如何解决，在看完下面的几个代码示例后在会看这个处理方法
 */
public class DisAppearRequest implements Runnable {
    static DisAppearRequest disAppearRequest = new DisAppearRequest();

    static int i = 0;

    @Override
    public void run() {
        for (int j = 0; j < 100000; j++) {
            i++;
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(disAppearRequest);
        Thread thread2 = new Thread(disAppearRequest);
        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();
        System.out.println(i);//144171 结果不是固定的
    }
}

开启了2个线程，每个线程都累加了100000次，如果结果正确的话自然而然总数就应该是2* 1000000 = 2000000。可就运行多次结果都不是这个数，而且每次运行结果都不一样。这是为什么了？有什么解决方案了？这就是我们今天要聊的事情。

二：synchronized介绍以及案例

1、synchronized的基本使用：

Synchronized是Java中解决并发问题的一种最常用的方法，也是最简单的一种方法。

2、synchronized的实现原理：

在java代码中使用synchronized可是使用在代码块和方法中，根据Synchronized用的位置可以有这些使用场景：

如图，synchronized可以用在方法上也可以使用在代码块中，其中方法是实例方法和静态方法分别锁的是该类的实例对象和该类的对象。而使用在代码块中也可以分为三种，具体的可以看上面的表格。这里的需要注意的是：如果锁的是类对象的话，尽管new多个实例对象，但他们仍然是属于同一个类依然会被锁住，即线程之间保证同步关系。

这里通过一些代码例子来对synchronized进行讲解。这里是看了悟空的课程，然后加上自己的理解来记录一下。

案例一：两个线程同时访问同一个对象的同步方法，结果是什么？

对象锁 这里是代码块形式  this 对象，这里的this对象指的是 synchronizedCodeBlock1

package synchronizedlearn;

/**
 * 同步代码块
 */
public class SynchronizedCodeBlock1 implements Runnable{

    static SynchronizedCodeBlock1 synchronizedCodeBlock1 = new SynchronizedCodeBlock1();

    @Override
    public void run() {
        synchronized (this){
            System.out.println("我是对象锁的代码块形式,name is "+Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("我是对象锁的代码块形式,name is "+Thread.currentThread().getName()+"执行结束");
        }
    }

    public static void main(String[] args) {
        Thread thread1 = new Thread(synchronizedCodeBlock1);
        Thread thread2 = new Thread(synchronizedCodeBlock1);
        thread1.start();
        thread2.start();
        while (thread1.isAlive() || thread2.isAlive()){

        }
        System.out.println("finish");
    }
}

对象锁代码块形式  object 对象

package synchronizedlearn;


/**
 * 同步代码块
 */
public class SynchronizedCodeBlock1 implements Runnable{

    static SynchronizedCodeBlock1 synchronizedCodeBlock1 = new SynchronizedCodeBlock1();

    Object lock1 = new Object();
    Object lock2 = new Object();

    @Override
    public void run() {
        synchronized (lock1){
            System.out.println("lock1---->"+"我是对象锁的代码块形式,name is "+Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("lock1---->"+"我是对象锁的代码块形式,name is "+Thread.currentThread().getName()+"执行结束");
        }
        synchronized (lock2){
            System.out.println("lock2---->"+"我是对象锁的代码块形式,name is "+Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("lock2---->"+"我是对象锁的代码块形式,name is "+Thread.currentThread().getName()+"执行结束");
        }
    }

    public static void main(String[] args) {
        Thread thread1 = new Thread(synchronizedCodeBlock1);
        Thread thread2 = new Thread(synchronizedCodeBlock1);
        thread1.start();
        thread2.start();
        while (thread1.isAlive() || thread2.isAlive()){

        }
        System.out.println("finish");
    }
}

对象锁 方法形式

package synchronizedlearn;

public class SynchronizedMethod1 implements Runnable{
    static SynchronizedMethod1 synchronizedMethod1 = new SynchronizedMethod1();
    @Override
    public void run() {
        method();
    }

    public synchronized void method(){
        System.out.println("我是对象锁的方法修饰符形式,name is "+Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("我是对象锁的方法修饰符形式,name is "+Thread.currentThread().getName()+"执行结束");
    }

    public static void main(String[] args) {
        Thread thread1 = new Thread(synchronizedMethod1);
        Thread thread2 = new Thread(synchronizedMethod1);
        thread1.start();
        thread2.start();
        while (thread1.isAlive() || thread2.isAlive()){

        }
        System.out.println("finish");
    }
}

synchronized用在方法上，每个类实例对应一把锁，每个 synchronized 方法都必须获得调用该方法的类实例的锁方能执行，否则所属线程阻塞，方法一旦执行，就独占该锁，直到从该方法返回时才将锁释放，此后被阻塞的线程方能获得该锁，重新进入可执行状态。这种机制确保了同一时刻对于每一个类实例，其所有声明为 synchronized 的成员函数中至多只有一个处于可执行状态（因为至多只有一个能够获得该类实例对应的锁），从而有效避免了类成员变量的访问冲突（只要所有可能访问类成员变量的方法均被声明为 synchronized）。

案例二：两个线程访问synchronized的静态方法，结果如何？

从这个案例可以看出静态同步方法锁的类的对象

package synchronizedlearn;

/**
 * 类锁的第一种形式
 *        synchronized static 形式
 *        synchronized 用在普通方法和静态方法上的区别！！！
 */
public class SynchronizedClassStatic implements Runnable{
    static SynchronizedClassStatic synchronizedClassStatic1 = new SynchronizedClassStatic();
    static SynchronizedClassStatic synchronizedClassStatic2 = new SynchronizedClassStatic();

    public static synchronized void method(){
        System.out.println("我是对象锁的代码块形式,name is "+Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("我是对象锁的代码块形式,name is "+Thread.currentThread().getName()+"执行结束");
    }

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

    public static void main(String[] args) {
        Thread thread1 = new Thread(synchronizedClassStatic1);
        Thread thread2 = new Thread(synchronizedClassStatic2);
        thread1.start();
        thread2.start();
        while (thread1.isAlive() || thread2.isAlive()){

        }
        System.out.println("finish");

    }
}

 

package synchronizedlearn;

/**
 * 类锁的第二种形式
 */
public class SynchronizedClassClass implements Runnable{
    static SynchronizedClassClass synchronizedClassClass1 = new SynchronizedClassClass();
    static SynchronizedClassClass synchronizedClassClass2 = new SynchronizedClassClass();
    public void method() {
        synchronized (SynchronizedClassClass.class){
            System.out.println("我是类锁的第二种形式,---->"+Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("该线程"+Thread.currentThread().getName()+"执行完毕");
        }
    }

    public static void main(String[] args) {
        Thread thread1 = new Thread(synchronizedClassClass1);
        Thread thread2 = new Thread(synchronizedClassClass2);
        thread1.start();
        thread2.start();
        while (thread1.isAlive() || thread2.isAlive()){

        }
        System.out.println("finish");

    }

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

 

案例三：同时访问静态synchronized方法和非静态synchronized方法 类锁和对象锁不是锁住的同一个对象相互不影响

实例方法和静态方法分别锁的是该类的实例对象和该类的对象。从这个案例中我们可以看出，该类的实例对象和该类对象不是同一个。

package synchronizedlearn;
/**
 * 同时访问静态synchronized方法和非静态synchronized方法
 */
public class SynchronizedStaticAndNormal implements Runnable{
    static SynchronizedStaticAndNormal synchronizedStaticAndNormal = new SynchronizedStaticAndNormal();
    @Override
    public void run() {
        if (Thread.currentThread().getName().equals("Thread-0")){
            method1();
        }else{
            method2();
        }
    }

    public static synchronized void method1(){
        System.out.println("我是静态加锁的方法,name is "+Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("我是加锁的方法,name is "+Thread.currentThread().getName()+"执行结束");
    }

    public synchronized void method2(){
        System.out.println("我是非静态加锁的方法,name is "+Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("我是加锁的方法,name is "+Thread.currentThread().getName()+"执行结束");
    }


    public static void main(String[] args) {
        Thread thread1 = new Thread(synchronizedStaticAndNormal);
        Thread thread2 = new Thread(synchronizedStaticAndNormal);
        thread1.start();
        thread2.start();
        while (thread1.isAlive() || thread2.isAlive()){

        }
        System.out.println("finish");
    }
}

 案例 四：同时访问同一对象的不同的同步方法：锁生效

package synchronizedlearn;

/**
 * 同时访问同一个对象的不同的普通同步方法
 */
public class SynchronizedDifferenceMethod implements Runnable {
    static SynchronizedDifferenceMethod synchronizedDifferenceMethod = new SynchronizedDifferenceMethod();

    @Override
    public void run() {
        if (Thread.currentThread().getName().equals("Thread-0")){
            method1();
        }else{
            method2();
        }
    }

    public synchronized void method1(){
        System.out.println("我是加锁的方法,name is "+Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("我是加锁的方法,name is "+Thread.currentThread().getName()+"执行结束");
    }

    public synchronized void method2(){
        System.out.println("我是加锁的方法,name is "+Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("我是加锁的方法,name is "+Thread.currentThread().getName()+"执行结束");
    }


    public static void main(String[] args) {
        Thread thread1 = new Thread(synchronizedDifferenceMethod);
        Thread thread2 = new Thread(synchronizedDifferenceMethod);
        thread1.start();
        thread2.start();
        while (thread1.isAlive() || thread2.isAlive()){

        }
        System.out.println("finish");
    }
}

 案例五：同时访问同步方法和非同步方法，锁是什么情况？ 非同步方法不受影响

/**
 * 同时访问同步方法和非同步方法（同步方法指的是被Synchronized修饰的方法）
 *
 */
public class SynchronizedYesAndNo implements Runnable {

    static SynchronizedYesAndNo synchronizedYesAndNo = new SynchronizedYesAndNo();

    @Override
    public void run() {
        if (Thread.currentThread().getName().equals("Thread-0")){
            method1();
        }else{
            method2();
        }
    }

    public synchronized void method1(){
        System.out.println("我是加锁的方法,name is "+Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("我是加锁的方法,name is "+Thread.currentThread().getName()+"执行结束");
    }

    public  void method2(){
        System.out.println("我是没加锁的方法,name is "+Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("我是没加锁的方法,name is "+Thread.currentThread().getName()+"执行结束");
    }


    public static void main(String[] args) {
        Thread thread1 = new Thread(synchronizedYesAndNo);
        Thread thread2 = new Thread(synchronizedYesAndNo);
        thread1.start();
        thread2.start();
        while (thread1.isAlive() || thread2.isAlive()){

        }
        System.out.println("finish");
    }
}

关于synchronized的总结：

    两个线程同时访问一个对象的同步方法 --->相互等待，锁生效。
    两个线程访问两个对象的同步方法 --->相互没有影响，锁无效
    两个线程访问synchronized的静态方法 --->即使实例不同，锁也生效。
    同时访问同步方法与非同步方法  ---> 非同步方法不受影响
    同时访问同一个对象的不同的普通同步方法 ---> 锁生效
    同时访问静态synchronized方法和非静态synchronized方法 --->类锁和对象锁不是锁住的同一个对象相互不影响
    方法抛出异常后会释放锁
程序员孙大圣
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
synchronized详解
weixin_53818213的博客
09-06 323
synchronized简介，使用，底层原理，synchronized的优化，锁对比等。
synchronized.md
02-24
关于synchronized的自学笔记
Java中Synchronized的用法
热门推荐
阳光日志
06-24 50万+
synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种： 1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象； 2. 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象； 3.修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象； 4..
关键字: synchronized详解
最新发布
qq_63353796的博客
06-19 877
在C程序代码中我们可以利用操作系统提供的互斥锁来实现同步块的互斥访问及线程的阻塞及唤醒等工作。在Java中除了提供Lock API外还在语法层面上提供了synchronized关键字来实现互斥同步原语, 本文将对synchronized关键字详细分析。
值得保存的 synchronized 关键字总结
weixin_34071713的博客
09-07 374
该文已加入开源文档：JavaGuide（一份涵盖大部分Java程序员所需要掌握的核心知识）。地址:github.com/Snailclimb/…. 本文是对 synchronized 关键字使用、底层原理、JDK1.6之后的底层优化以及和ReenTrantLock对比做的总结。如果没有学过 synchronized 关键字使用的话，阅读起来可能比较费力。两篇比较基础的讲解 synchroniz...
Synchronized
STU17xkx的博客
04-10 285
对像锁： 包括方法锁（默认锁对象为this当前实例对象） 和同步代码块锁（自己指定锁对象）。 类锁： 指synchronize修饰静态的方法或指定锁为Class对象。 public class demo implements Runnable{ Object lock1 = new Object(); Object lock2 = new Object(); @Override p...
synchronized并发讲解源码.zip
03-16
在Java编程语言中，`synchronized`关键字是一个非常重要的并发控制机制，用于保证多线程环境下的数据一致性。本文将深入解析`synchronized`的工作原理、使用方式以及它在并发编程中的重要性。通过分析提供的源码，...
详解java中的synchronized关键字
09-03
在Java编程语言中，`synchronized`关键字是一个重要的并发控制机制，用于确保多线程环境下的数据一致性。本文将深入探讨`synchronized`关键字的使用和功能。 首先，`synchronized`关键字可以应用于方法和代码块，以...
Java中synchronized正确使用方法解析
08-25
Java 中 synchronized 正确使用方法解析 Java 中 synchronized 关键字是解决线程安全问题的重要手段，它可以确保在多线程环境下，共享资源的访问安全性。本文将详细介绍 Java 中 synchronized 的正确使用方法，通过...
简单了解synchronized和lock的区别
08-25
了解synchronized和lock的区别 synchronized是Java语言中的一个关键字，用于线程同步，主要用于解决多线程之间的竞争问题。它可以将某个方法或代码块锁定，使得只有一个线程可以执行该方法或代码块，其他线程只能...
Java使用synchronized修饰方法来同步线程的实例演示
09-02
在Java编程语言中，synchronized关键字用于实现线程同步，以确保多线程环境下的数据一致性。它主要用于控制对共享资源的并发访问，防止多个线程同时进入临界区，可能导致数据不一致或竞态条件的问题。本文将深入探讨...
透彻理解Java中Synchronized（对象锁）和Static Synchronized（类锁）的区别
08-27
Java 中 Synchronized（对象锁）和 Static Synchronized（类锁）的区别 Synchronized 和 Static Synchronized 是 Java 中两种同步机制，它们都用于解决多线程并发访问的安全问题。然而，它们之间存在着本质的区别。...
Java关键字volatile和synchronized作用和区别
08-30
Java关键字volatile和synchronized作用和区别 Java关键字volatile和synchronized是Java语言中两个常用的关键字，它们都是用来解决多线程编程中的同步问题的，但它们的作用和用法却有所不同。 volatile关键字是变量...
你还在用Synchronized?Atomic你了解不?
08-26
Synchronized关键字是我们常见的一个同步原语，它提供了一种锁机制，确保了对共享资源的互斥访问。然而，随着Java并发库的发展，Atomic类（如AtomicInteger、AtomicLong等）逐渐成为一种更加轻量级且高效的替代方案...
Java中synchronized关键字修饰方法同步的用法详解
09-02
【Java中synchronized关键字修饰方法同步的用法详解】 在Java多线程编程中，synchronized关键字是一个重要的同步工具，它能确保共享资源在多线程环境下的安全访问。synchronized可以用来同步静态和非静态方法，从而...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值