Synchronized简介与使用

最新推荐文章于 2022-04-16 20:33:34 发布
最新推荐文章于 2022-04-16 20:33:34 发布
阅读量126 收藏
点赞数
分类专栏： Java多线程 文章标签： java线程同步 Synchronized
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/b15735105314/article/details/100537177
版权

1、Synchronized的作用

能够保证在同一时刻最多只有一个线程执行该段代码，已达到保证并发安全的效果。

如果没有Synchronized去保证并发安全，那么程序运行的结果会有差错。

实例代码：

public class MyRunnable implements Runnable{
    private static int a = 0;
    private static MyRunnable run1 = new MyRunnable();

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(run1);
        Thread t2 = new Thread(run1);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("最终运算结果=========" + a);
    }

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

实例运行结果为： 最终运算结果=========16079（当然也可以是其他数值，反正就是无法确定）

2、Synchronized的两种用法

1）对象锁：包括方法锁（默认锁对象为this当前实例对象）和同步代码块锁（自己指定所对象）

实例代码（同步代码块锁之锁定this对象）：

public class SynchronizedObjectCodeBlock implements Runnable {
    private static SynchronizedObjectCodeBlock synchronizedObjectCodeBlock = new
            SynchronizedObjectCodeBlock();

    @Override
    public void run() {
        synchronized(this) {
            System.out.println("代码块运行开始\t" + Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("代码块运行结束\t" + Thread.currentThread().getName());
        }
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(synchronizedObjectCodeBlock);
        Thread t2 = new Thread(synchronizedObjectCodeBlock);
        t1.start();
        t2.start();
        //线程的isAlive()方法的功能是判断当前线程是否处于活动状态（就绪状态或者运行状态）
        //下面的循环会在两个线程都运行结束后 结束
        while(t1.isAlive() || t2.isAlive()){

        }
        System.out.println("程序运行结束");
    }
}


实例运行结果：

代码块运行开始    Thread-0
代码块运行结束    Thread-0
代码块运行开始    Thread-1
代码块运行结束    Thread-1
程序运行结束

 

示例代码（同步代码块锁之锁定object对象）：

public class SynchronizedObjectCodeBlock implements Runnable {
    private static SynchronizedObjectCodeBlock synchronizedObjectCodeBlock = new
            SynchronizedObjectCodeBlock();
    private Object object = new Object();

    @Override
    public void run() {
        synchronized(object) {
            System.out.println("代码块运行开始\t" + Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("代码块运行结束\t" + Thread.currentThread().getName());
        }
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(synchronizedObjectCodeBlock);
        Thread t2 = new Thread(synchronizedObjectCodeBlock);
        t1.start();
        t2.start();
        //线程的isAlive()方法的功能是判断当前线程是否处于活动状态（就绪状态或者运行状态）
        //下面的循环会在两个线程都运行结束后 结束
        while(t1.isAlive() || t2.isAlive()){

        }
        System.out.println("程序运行结束");
    }
}

实例运行结果：

代码块运行开始    Thread-0
代码块运行结束    Thread-0
代码块运行开始    Thread-1
代码块运行结束    Thread-1
程序运行结束

 

实例代码（方法锁）：

public class SynchronizedObjectMethod implements Runnable {
    private static SynchronizedObjectMethod synchronizedObjectMethod = new
            SynchronizedObjectMethod();

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

    public synchronized void test(){
        System.out.println("test()方法运行开始" + Thread.currentThread().getName());
        System.out.println("test()方法运行结束" + Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(synchronizedObjectMethod);
        Thread t2 = new Thread(synchronizedObjectMethod);
        t1.start();
        t2.start();
        //线程的isAlive()方法的功能是判断当前线程是否处于活动状态（就绪状态或者运行状态）
        //下面的循环会在两个线程都运行结束后 结束
        while(t1.isAlive() || t2.isAlive()){

        }
        System.out.println("程序运行结束");
    }
}

运行结果：
test()方法运行开始Thread-0
test()方法运行结束Thread-0
test()方法运行开始Thread-1
test()方法运行结束Thread-1
程序运行结束

2）类锁：指Synchronized修饰静态的方法或指定锁为Class对象

概念：Java类可能有很多个对象，但是只有一个Class对象(举例：Student类可以创建出很多的实例对象，如student1,student2,...,在Java中每一个类都有且只有一个对应的Class对象)，

本质：所谓的类锁其实就是类的Class对象的锁，不同的实例之间会产生互斥，

用法和效果：类锁只能在同一时刻被一个对象拥有，即一旦运用了类锁之后，只有一个对象能拥有这个类锁，其他对象如果想要竞争这个类锁会被阻塞

 

形式1：synchronized加在static方法上

实例代码（synchronized加在普通方法上）：

public class SynchronizedClassStatic implements Runnable {
    private static SynchronizedClassStatic instance1 = new SynchronizedClassStatic();
    private static SynchronizedClassStatic instance2 = new SynchronizedClassStatic();

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

    public synchronized void test(){
        System.out.println("test()方法运行开始\t" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("test()方法运行结束\t" + Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(instance1);
        Thread t2 = new Thread(instance2);
        t1.start();
        t2.start();
        //线程的isAlive()方法的功能是判断当前线程是否处于活动状态（就绪状态或者运行状态）
        //下面的循环会在两个线程都运行结束后 结束
        while(t1.isAlive() || t2.isAlive()){

        }
        System.out.println("程序运行结束");

    }
}

代码运行结果：
test()方法运行开始	Thread-0
test()方法运行开始	Thread-1
test()方法运行结束	Thread-1
test()方法运行结束	Thread-0
程序运行结束

实例代码（synchronized加在static方法上）：

public class SynchronizedClassStatic implements Runnable {
    private static SynchronizedClassStatic instance1 = new SynchronizedClassStatic();
    private static SynchronizedClassStatic instance2 = new SynchronizedClassStatic();

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

    public static synchronized void test(){
        System.out.println("test()方法运行开始\t" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("test()方法运行结束\t" + Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(instance1);
        Thread t2 = new Thread(instance2);
        t1.start();
        t2.start();
        //线程的isAlive()方法的功能是判断当前线程是否处于活动状态（就绪状态或者运行状态）
        //下面的循环会在两个线程都运行结束后 结束
        while(t1.isAlive() || t2.isAlive()){

        }
        System.out.println("程序运行结束");

    }
}


代码运行结果：
test()方法运行开始	Thread-0
test()方法运行结束	Thread-0
test()方法运行开始	Thread-1
test()方法运行结束	Thread-1
程序运行结束

形式2：synchronized(*.class) {代码块}

示例代码（synchronized去锁定普通对象）

public class SynchronizedClassClass implements Runnable {
    private static SynchronizedClassClass instance1 = new SynchronizedClassClass();
    private static SynchronizedClassClass instance2 = new SynchronizedClassClass();

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

    public void test(){
        synchronized(this) {
            System.out.println("test()方法运行开始\t" + Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("test()方法运行结束\t" + Thread.currentThread().getName());
        }
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(instance1);
        Thread t2 = new Thread(instance2);
        t1.start();
        t2.start();
        //线程的isAlive()方法的功能是判断当前线程是否处于活动状态（就绪状态或者运行状态）
        //下面的循环会在两个线程都运行结束后 结束
        while(t1.isAlive() || t2.isAlive()){

        }
        System.out.println("程序运行结束");
    }
}

代码运行结果：
test()方法运行开始	Thread-0
test()方法运行开始	Thread-1
test()方法运行结束	Thread-0
test()方法运行结束	Thread-1
程序运行结束

代码实例（synchronized去锁定Class对象）：

public class SynchronizedClassClass implements Runnable {
    private static SynchronizedClassClass instance1 = new SynchronizedClassClass();
    private static SynchronizedClassClass instance2 = new SynchronizedClassClass();

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

    public void test(){
        synchronized(SynchronizedClassClass.class) {
            System.out.println("test()方法运行开始\t" + Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("test()方法运行结束\t" + Thread.currentThread().getName());
        }
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(instance1);
        Thread t2 = new Thread(instance2);
        t1.start();
        t2.start();
        //线程的isAlive()方法的功能是判断当前线程是否处于活动状态（就绪状态或者运行状态）
        //下面的循环会在两个线程都运行结束后 结束
        while(t1.isAlive() || t2.isAlive()){

        }
        System.out.println("程序运行结束");
    }
}

代码运行结果：
test()方法运行开始	Thread-0
test()方法运行结束	Thread-0
test()方法运行开始	Thread-1
test()方法运行结束	Thread-1
程序运行结束

 

注：多个thread对象在创建的时候，可以使用同一个Runnable对象作为初始参数，而且可以使用Synchronized将这个Runnable对象锁住，使多个thread对象在使用该Runnable对象的时候，达到并发安全。Synchronized可以直接修饰Runnable对象的run()方法。

延伸：使用idea进行线程调试的方法（3分钟）：https://www.imooc.com/video/18484/0

 

 

b15735105314
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
synchronized详解
12-24
synchronized详解，很详细。
Synchronized简单介绍(原理、使用、对比分析)
haovin的博客
06-04 363
0、目录 一、介绍 二、原理 三、具体使用 四、总结 一、介绍 二、原理 Synchronized在JVM中实现的原理。每一个对象都有一个监视器锁（monitor），JVM通过进入或退出monitor对象来实现方法同步和代码块同步。monitorenter指令是同步开始的位置，monitorexit是同步结束的位置，两者成对出现。 monitorenter: 线程执行moni...
简介synchronized
weixin_43647087的博客
03-07 79
1.synrhronized关键字简洁、清晰、语义明确，因此即使有了Lock接口，使用的还是非常广泛。 2.其应用层的语义是可以把任何一个非null对象作为"锁"，当synchronized作用在方法上时，锁住的便是对象实例（this）； 3.当作用在静态方法时锁住的便是对象对应的Class实例，因为Class数据存在于永久带，因此静态方法锁相当于该类的一个全局锁； 4.当synchronized...
Synchronized简介
doublez的博客
05-18 5462
Synchronized的正确用法 修饰实例方法 /** * @Author: zenghzong * @Description: * @Date: Create in 16:18 2020/5/18 */ public class Main { public synchronized void test(){ } } 修饰静态方法 public class Main { public void test(){ synchronized(Main.
synchronized简介
number_chc的专栏
09-18 543
Java语言的关键字，可用来给对象和方法或者代码块加锁，当它锁定一个方法或者一个代码块的时候，同一时刻最多只有一个线程执行这个段代码。当两个并发线程访问同一个对象object中的这个加锁同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。然而，当一个线程访问object的一个加锁代码块时，另一个线程仍然可以访问该object中的非加锁代码
ReentrantLock 与 synchronized 简介
12-24
java lock synchronized
Java 并发编程学习笔记之Synchronized简介
09-02
虽然多线程编程极大地提高了效率，但是也会带来一定的隐患。比如说两个线程同时往一个数据库表中插入不重复的数据，就可能会导致数据库中插入了相同的数据。今天我们就来一起讨论下线程安全问题，以及Java中提供了...
SMIL 3.0格式简介
05-04
SMIL 3.0 格式简介 SMIL（Synchronized Multimedia Integration Language）是同步多媒体集成语言，用于描述多媒体内容的 timing 和 layout。SMIL 3.0 是 W3C（World Wide Web Consortium）发布的最新版本，提供了更...
Java理论与实践：非阻塞算法简介
03-04
本文介绍了在Java理论与实践中，几种比较简单的非阻塞算法的工作方式。在不只一个线程访问一个互斥的变量时，所有线程都必须使用同步，否则就可能会发生一些非常糟糕的事情。Java语言中主要的同步手段就是...
单例模式简介
12-22
知识回顾 ... 特征修饰符：final、static、abstract、native、transient、synchronized、volatile final:  修饰变量：只有一次赋值的机会、赋值之后值不能发生改变  属性：要求必须赋初始值、不能
synchronized的简介
l1161558158的博客
05-04 216
自旋和自适应自旋 自旋等待其他占用锁的线程释放. 自适应的自旋,由前一次在同一个锁上的自旋时间和锁的拥有者状态来判断.是否进行自旋,以及自旋的次数 锁消除 在JIT中,如果检测到不可能存在数据竞争,则会直接消除锁,例如在一个方法内部定义StringBuffer并操作,会被替换为StringBuilder. 锁粗化 在一系列的连续操作中都对同一个对象反复加锁和解锁,会把锁同步的范围扩展.以避免频繁的...
Synchronized的简介
lantian0802的专栏
05-19 679
记下来，很重要。 Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。      一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。      二、然而，当一个线程访问ob
Synchronized介绍
weixin_30906425的博客
01-04 73
来源 https://www.imooc.com/learn/1086 作用 ​ 同步方法支持一种简单的策略来防止线程干扰和内存一致性错误，如果一个对象对多个线程可见，则对该对象变量的所有读取或写入都是通过同步方法完成的。 ​ 即：能够保证在同一时刻最多只有一个线程执行该段代码，达到保证并发安全的效果。 Synchronized是Java的关键字，被Java原生支持。 是最基本的互斥同步手段。 ...
synchronized的介绍
u011521890的专栏
09-12 485
我对synchronized关键字算是很熟悉的了，但是有些时候一些概念还是没有搞明白，今天通过对wiki翻译以及博客的学习，从概念和类别上对其进行区分，并整理了一套自己的理解方式。 从类别来区分 从类别上可以将锁分为类级别锁和对象级别锁 1. 类级别锁，作用于整个类的的同步锁，例如Object.class 2. 对象级别锁，new Object()产生的锁，不同的实例所持有的锁是不同的
内置锁（一）--- synchronized 介绍与用法
jinggod的博客
11-01 467
一、synchronized 的介绍  synchronized 是 Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码，而这段代码也被称为临界区。  synchronized 有多个叫法，而每个叫法都表明synchronized 的特性：1、内置锁（又叫 隐式锁）：synchronized 是内置于JDK中的，底层实现是nativ
synchronized 简单介绍
m0_45247842的博客
07-07 161
synchronized 线程安全是Java并发编程重点，synchronized是Java中的关键字，是一种同步锁，可以有效解决线程安全问题。 在Java中，synchronized关键字可以保证在同一时刻，只有一个线程可以执行某个方法或某个代码块，并且使得一个线程中，共享数据的变化可以被其他线程看到（可见性，代替volatile功能），synchronized为互斥锁（存在多个线程操作共享数据时，其他线程必须等待该线程处理完之后再进行）。 1、Java对象的组成 在jvm中，对象在内存中的布局分为3部分
Synchronized全面介绍
qq_40729302的博客
04-16 1476
Synchronized 并发编程的三个重要特性： 原子性：一个操作或者多次操作，要么所有操作全部得到执行，并且不会受到任何因素的干扰而中断，要么所有的操作都执行，要么都不执行。 可见性：当一个线程对共享变量进行修改，另外的线程可以立即得到修改后的最新的值。 有序性：程序在多线程下，程序中代码执行的顺序是代码的先后执行的。程序代码不会因为指令重排序（程序为了优化执行效率从而打乱了代码的执行顺序）而打乱，从而导致程序产生不同的结果。 synchronized可以保证原子性，有序性和可见性 另一个关键字v
synchronized使用
最新发布
09-06
在方法上使用synchronized关键字，可以确保同一时间只有一个线程可以访问该方法。而在代码块上使用synchronized关键字，可以确保同一时间只有一个线程可以访问被同步的代码块。 在引用中，演示了在同步代码块中使用...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值