synchronize关键字

最新推荐文章于 2022-08-02 12:56:38 发布
最新推荐文章于 2022-08-02 12:56:38 发布
阅读量1k 收藏 3
点赞数 1
分类专栏： JAVA基础 文章标签： synchronize threadlocal volatile java线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/muerhuoxu/article/details/86009229
版权

java线程相关的3个关键字synchronize、ThreadLocal、volatile也许在我们平常保持数据一致性场景中用到不多，因为它们都是基于JVM的特征，而我们的应用一般都是集群部署，分布式环境下线程的一致性几乎用不到它们，但在一些底层的源码中，还会看到他们的身影，比如ConcurrentHashMap、StringBuffer中，synchronize为线程安全保驾护航，那么接下来看下它们都有哪些特性

synchronize

用synchronize关键字来修饰一个方法、一个代码块的时候，能保证同一个时刻只能有一个线程可以执行，具体的特性：

1. 当2个并发线程访问同1个对象object中的这个synchronized方法时，一个时间内只能有1个线程得到执行。另一个线程必须等待当前线程执行完这个方法以后才能执行该方法 (潜台词是如果2个线程并发访问2个对象的synchronize方法时，是异步执行的，可见注释掉的代码)。

看下代码：

package com.syj.test.thread;

/**
* Created by syj on 2019/1/7.
*
* @DESC 2个并发线程访问1个对象的synchronized方法时，一个时间内只能有一个线程得到执行
*/
public class SynchronizedDemo1 {

   public synchronized void synMeth() {
       for (int i = 0; i < 500; i++) {
           System.out.println(Thread.currentThread().getName() + " synchronized loop " + i);
       }
   }

   public static void main(String[] args) {
       //2个线程同时访问1个对象的synchronize方法，一个时间只能有一个线程得到执行
       final SynchronizedDemo1 t1 = new SynchronizedDemo1();

       Thread ta = new Thread(new Runnable() {
           public void run() {
               t1.synMeth();
           }
       }, "A");
       Thread tb = new Thread(new Runnable() {
           public void run() {
               t1.synMeth();
           }
       }, "B");

       ta.start();
       tb.start();

       //2个线程同时访问2个对象的synchronize方法，互不影响(即一个时间可能有2个线程在执行)
       /*final SynchronizedDemo1 t2 = new SynchronizedDemo1();
       final SynchronizedDemo1 t3 = new SynchronizedDemo1();
       Thread tc = new Thread(new Runnable() {
           public void run() {
               t2.synMeth();
           }
       }, "C");
       Thread td = new Thread(new Runnable() {
           public void run() {
               t3.synMeth();
           }
       }, "D");
       tc.start();
       td.start();*/
   }
}

执行结果如下，线程A、B是串行执行的，线程C、D是交叉执行的，因为C、D对应的是2个对象嘛，锁的不是同一个对象，当然互不影响了(每台机器CPU的执行结果的顺序会不同，为了得到真实的结果，建议多运行几次来观察)
线程A 、B执行结果
线程C D交叉执行

2. 当1个线程访问object的一个synchronized方法时，另1个线程仍然可以访问该object中的非synchronized方法。

看下代码：

package com.syj.test.thread;

/**
 * Created by syj on 2019/1/7.
 * @DESC 1个线程访问某个object的synchronized方法、synchronize代码块时，其他并发线程仍然可以访问该object的非synchronize方法
 */
public class SynchronizedDemo2 {

    public synchronized void synMethod() {
            for (int i=0; i<500; i++) {
                System.out.println(Thread.currentThread().getName() + " syn loop " + i);
            }
    }

    public void noSynMethod() {
        for (int i=0; i<500; i++) {
            System.out.println(Thread.currentThread().getName() + " nosyn loop " + i);
        }
    }

    public static void main(String[] args) {
        final SynchronizedDemo2 obj = new SynchronizedDemo2();

        //1个线程访问1个object的synchronize方法，其他并发线程可以访问该object的非synchronize方法
        Thread t1 = new Thread(new Runnable() {
            public void run() {
                obj.synMethod();
            }
        }, "t1");

        Thread t2 = new Thread(new Runnable() {
            public void run() {
                obj.noSynMethod();
            }
        }, "t2");

        t1.start();
        t2.start();
    }
}

执行结果如下：
在这里插入图片描述
synchronize方法和非synchronize方法交叉执行，互不影响。但这在某些场景下，会发生脏读，就是使用了synchronize方法，但得到的并不是我想要的结果，看下面这个脏读的case：

package com.syj.test.thread;

/**
 * Created by syj on 2019/1/7.
 * @DESC 多线程访问中的脏读
 */
public class SynchronizedDemo6 {

    private int num = 10;

    public synchronized void synMethod() {
        try {
            //模拟业务处理
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        num += 1;
        System.out.println("thread name : " + Thread.currentThread().getName() + ", synMethod, num=" + num);
    }

    public void noSynMethod() {
        System.out.println("thread name : " + Thread.currentThread().getName() + ", noSynMethod, num=" + num);
    }

    public static void main(String[] args) {
        final SynchronizedDemo6 obj = new SynchronizedDemo6();

        new Thread(new Runnable() {
            public void run() {
                obj.synMethod();
            }
        }, "t1").start();

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //发生脏读
        new Thread(new Runnable() {
            public void run() {
                obj.noSynMethod();
            }
        }, "t2").start();
    }
}

执行结果如下：
脏读
线程t1执行了synMethod后，num应该变为11，但是线程t2通过noSynMethod去打印，发现还是之前的值，那该怎么处理呢？那就接下来看看下一个case吧

3. 当1个线程访问object的一个synchronized方法时，其他线程对object中所有其它synchronized方法的访问将被阻塞。

package com.syj.test.thread;

/**
 * Created by syj on 2019/1/7.
 *
 * @DESC 1个线程访问某个object的synchronized方法时，其他并发线程对该object的所有其他
 * synchronize方法的访问都将被阻塞
 */
public class SynchronizedDemo3 {

    private int num = 10;

    public synchronized void synMethod1() {
        try {
            //模拟业务处理
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        num += 1;
        System.out.println("thread name : " + Thread.currentThread().getName() + ", synMethod1, num=" + num);
    }

    public synchronized void synMethod2() {
        System.out.println("thread name : " + Thread.currentThread().getName() + ", synMethod2, num=" + num);
    }

    public static void main(String[] args) throws Exception{
        final SynchronizedDemo3 obj = new SynchronizedDemo3();

        new Thread(new Runnable() {
            public void run() {
                obj.synMethod1();
            }
        }, "t1").start();

        Thread.sleep(1000);

        new Thread(new Runnable() {
            public void run() {
                obj.synMethod2();
            }
        }, "t2").start();
    }
}

看下结果，发现脏读消失了，两个线程是同步执行的，因为线程对方法的调用是串行执行的，随之而来的就是性能的消耗，那能不能有更细粒度的锁，比如对某个变量加锁，而不是对整个对象加锁？当然是有的，看下个例子
在这里插入图片描述

4. 不同的锁之间是异步的，比如变量锁和对象锁，互不影响，但每一种锁都有以上1、2、3种特性。 (锁就是一种对象监视器，不同的对象监视器之间是异步的)

看下代码：

package com.syj.test.thread;

/**
 * Created by syj on 2019/1/7.
 *
 * @DESC 1个线程访问1个object的synchronized变量时，另1个线程可以访问该object的synchronize方法
 * 这是因为1个是变量锁，一个是对象锁，它们之间不冲突
 */
public class SynchronizedDemo4 {
    private String lock = new String();
	
	//object对象锁
    public synchronized void synMeth() {
        for (int i = 0; i < 500; i++) {
            System.out.println(Thread.currentThread().getName() + " synMeth loop " + i);
        }
    }

    public void noSynMeth() {
		//变量锁
        synchronized (lock) {
            for (int i = 0; i < 500; i++) {
                System.out.println(Thread.currentThread().getName() + " synPara loop " + i);
            }
        }
    }

    public static void main(String[] args) {
        //1个线程访问synchronize的变量锁时，另一个并发线程可以访问synchronize方法
        final SynchronizedDemo4 t = new SynchronizedDemo4();

        Thread ta = new Thread(new Runnable() {
            public void run() {
                t.synMeth();
            }
        }, "A");

        Thread tb = new Thread(new Runnable() {
            public void run() {
                t.noSynMeth();
            }
        }, "B");

        ta.start();
        tb.start();
    }
}

执行结果：
在这里插入图片描述
synchronize(lock)是一种变量锁，非对象锁，那这种方式有什么好处呢？

如果在一个类中有很多synchronized方法，这时虽然能实现同步，但会受到阻塞，从而影响效率。但如果同步代码块锁的是非this对象，则synchronized(非this对象x)代码块中的程序与同步方法是异步的，不与其他锁this同步方法争抢this锁，大大提高了运行效率。

说明：synchronize修饰方法跟synchronize(this){}是一样的，它们都是针对object对象加锁。当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。

看下代码：

package com.syj.test.thread;

/**
 * Created by syj on 2019/1/7.
 *
 * @DESC synchronize修饰方法时，是this对象锁，跟synchronize(this)一样，都是this对象锁
 */
public class SynchronizedDemo5 {
	//object对象锁
    public synchronized void synMeth1() {
        for (int i = 0; i < 500; i++) {
            System.out.println(Thread.currentThread().getName() + " synMeth1 loop " + i);
        }
    }

    public void synMeth2() {
        //object对象锁
        synchronized (this) {
            for (int i = 0; i < 500; i++) {
                System.out.println(Thread.currentThread().getName() + " synMeth2 loop " + i);
            }
        }
    }

    public static void main(String[] args) {
        final SynchronizedDemo5 t = new SynchronizedDemo5();

        Thread ta = new Thread(new Runnable() {
            public void run() {
                t.synMeth1();
            }
        }, "A");

        Thread tb = new Thread(new Runnable() {
            public void run() {
                t.synMeth2();
            }
        }, "B");

        ta.start();
        tb.start();
    }
}

执行结果如下：
在这里插入图片描述

5. 锁重入：当一个线程得到一个对象锁之后，再次请求此对象锁时是可以再次得到该对象的锁的。这也说明在一个synchronize方法/块的内部调用本类的其他synchronize方法/块时，是永远可以得到锁的

package com.syj.test.thread;

/**
 * Created by syj on 2019/1/7.
 * @DESC 锁重入
 */
public class SynchronizedDemo7 {

    public synchronized void synMethod1() {
        System.out.println("thread name : " + Thread.currentThread().getName() + ", synMethod1 bengin");
        synMethod2();
        System.out.println("thread name : " + Thread.currentThread().getName() + ", synMethod1 end");
    }

    public synchronized void synMethod2() {
        System.out.println("thread name : " + Thread.currentThread().getName() + ", synMethod2 bengin");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("thread name : " + Thread.currentThread().getName() + ", synMethod2 end");    }

    public static void main(String[] args) {
        final SynchronizedDemo7 obj = new SynchronizedDemo7();

        //锁重入
        new Thread(new Runnable() {
            public void run() {
                obj.synMethod1();
            }
        }, "t1").start();


        new Thread(new Runnable() {
            public void run() {
                obj.synMethod1();
            }
        }, "t2").start();
    }
}

执行结果如下，线程t1拿到对象锁后，可以直接调用其他synchronize方法，其他线程等待t1释放锁后，才可以执行：
锁重入

volatile

待完善

FollowYourHeart2015
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
synchronized关键字的用法详解
03-17
synchronized关键字在java中的重要性 以及常用的方法 还有它的详解
Synchronize关键字
qq_43426255的博客
04-10 393
Synchronize关键字前言一、Synchronize关键字二、Volatile与Synchronize比较三、什么是CAS？Synchronize与CAS 悲观锁与乐观锁、自旋锁Wait与Notify 前言 上一篇文章中，虽然我们通过 volatile + Atomic操作保证了 ++ 的原子性 但如果我们对count除了++ 之外还需要做值的判断呢？ 比如总共只有200张票，不管谁卖出多少，只能卖200张，那就需要卖之前判断一下当前数量。 这种复合操作的原子性如何保证？ 答案是： synchron
Synchronized 关键字详解
swadian2008的博客
08-17 574
synchronized 是 Java 中的一种同步机制，用于实现线程之间的互斥和同步。当一个线程需要访问一个对象的同步代码块时，如果这个同步代码块已经被另一个线程所占用，那么当前线程就会被阻塞，直到另一个线程执行完毕并释放锁。只有获取到锁的线程才能执行同步代码块。使用关键字修饰一个方法时，该方法被称为同步方法。当一个线程访问一个对象的同步方法时，其他线程将被阻塞，直到该线程执行完毕并释放锁。同步方法的锁对象是当前实例对象。使用关键字修饰一段代码时，称该代码块为同步代码块。
Synchronize关键字详解
hello__word__的博客
10-11 1088
前言 synchronized关键字,多线程并发编程最常用关键字 作用 对于synchronized关键字的作用，简单来说一句话就可以概况： 在同一时刻，最多只有一个线程能执行该段代码。 以串行化的方式执行代码，自然不存在线程安全问题。 用法 synchronized关键字的用法大致可以分为两类：对象锁和类锁。当然，Java中一切皆对象，类也是对象。所以这里的对象锁中的对象可以认为是狭义上的对象。 对象锁：锁住的是一个对象，具体用法是利用synchronized关键字修饰非静态方法或者synchron
Synchronized关键字详解
H_xxxxd的博客
04-06 4213
文章目录一、Synchronized的使用1.1对象锁1.2类锁二、Synchronized原理分析2.1加锁和释放锁的原理 引入背景 线程安全是并发编程中的重要关注点，应该注意到的是，造成线程安全问题的主要诱因有两点 一是存在共享数据(也称临界资源) 二是存在多条线程共同操作共享数据。 因此为了解决这个问题，我们可能需要这样一个方案，当存在多个线程操作共享数据时，需要保证同一时刻有且只有一个线程在操作共享数据，其他线程必须等到该线程处理完数据后再进行，这种方式有个高尚的名称叫互斥锁，即能达到互斥访
java synchronized 变量_Java Synchronized的用法
weixin_35625530的博客
02-24 1479
synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种：1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；2. 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；3. 修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；4. ...
单例模式，属于创建类型的一种常用的软件设计模式 通过单例模式的方法创建的类在当前进程中只有一个实例（根据需要，也有可能一个线程中
最新发布
01-01
在懒汉式基础上利用synchronize关键字和volatile关键字确保第一次创建时没有线程间竞争而产生多个实例，仅第一次创建时同步，性能相对较高 登记式。作为创建类的全局属性存在，创建类被装载时创建 枚举。java中枚举...
Java Unsafe类的使用.docx
06-21
synchronize关键字修饰的代码块被加了独占锁，相同时间只能有一个线程访问其中的内容，在高并发下这必然会导致大量线程挂起，从用户态转为内核态，带来很大的消耗而且操作效率低下。CAS算法的出现使得在不使用...
Java对象锁和类锁全面解析（多线程synchronize
11-22
Java对象锁和类锁全面解析（多线程synchronized关键字）编程开发技术共14页.pdf.zip
Java-Interview:https
05-10
synchronize 关键字原理 多线程的三大核心 对锁的一些认知 ReentrantLock 实现原理 ConcurrentHashMap 的实现原理 线程池原理 深入理解线程通信 交替打印奇偶数 JVM Java 运行时内存划分 类加载机制 OOM 分析 垃圾...
java thread sync,Java 线程同步详解
weixin_36325174的博客
03-20 153
Java 线程同步根本上是要符合一个逻辑:加锁------>修改------>释放锁1、同步代码块示例如下：public class SyncBlock {static class DataWrap {int i;}static class SyncBlockThread extends Thread {private DataWrap date;public SyncBlockThr...
通过winscp软件实现windows与linux目录数据同步
gengyiping18的专栏
08-02 2584
synchronizelocal|remote|both‘local’-远程向本地同步|‘remote’-本地向远程同步|‘both’-互相同步。3、创建一个同步执行批处理autosync.bat,放在winscp安装根目录内上，调用bak.txt执行同步。问题现象需要将linux目录下的数据同步到windows目录下，布置rsync步骤麻烦。winscp下载地址https//winscp.net/eng/index.php。2、在winscp的安装目录下创建一个同步脚本。...
Synchronize使用静态变量作为对象锁
weixin_41289395的博客
12-08 2320
前言： 有人觉得使用静态变量作为对象锁，用的是类锁，还有人觉得静态变量在使用的过程中，里面的值改变，对象的地址会改变，所以用的就不是通一把锁，今天我们验证下。 一、使用同一把静态变量锁的情况： public class SynchronizeTest { public static List<Person>list1; static { list1 = ...
Java基础——synchronize关键字
JJBOOM425的博客
10-26 944
1、synchronize了解 ​ synchronized 关键字解决的是多个线程之间访问资源的同步性，持有这把锁会把里面的并发变成序列化， synchronized 关键字可以保证被它修饰的⽅法或者代码块在任意时刻只能有⼀个线程执⾏，是一个悲观锁，会导致效率低下。 注意：**构造方法不能使用 synchronized 关键字修饰。**构造方法本身就属于线程安全的，不存在同步的构造方法一说。 synchronized 关键字最主要的三种使⽤⽅式： ​ 1.修饰实例⽅法: 作⽤于当前对象实例加锁，进⼊同步
Synchronize关键字及锁优化机制 总结
suveng's blog
07-17 5241
作用 synchronized可以保证方法或者代码块在运行时，同一时刻只有一个方法可以进入到临界区，同时它还可以保证共享变量的内存可见性 锁优化机制 引用自 https://mp.weixin.qq.com/s?__biz=MzI5NTYwNDQxNA==&amp;amp;mid=2247483816&amp;amp;idx=1&amp;amp;sn=16c0f7f48bddb2d7ca6546d1cf...
Synchronized 关键字原理
热门推荐
钱立清的博客
10-13 6万+
众所周知synchronized关键字是解决并发问题常用解决方案，有以下四种使用方式： 修饰代码块，即同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象。 修饰方法，即同步方法，其作用的范围是整个方法，作用的对象是调...
java中关于synchronize关键字的一些解释
weixin_43889681的博客
03-25 969
在编写一个类时，如果该类中的代码可能运行与多线程环境下，就要考虑同步问题了。 会同时被多个线程访问的资源，就是竞争资源，也称为竞争条件。对于多线程共享的资源我们必须进行同步，以避免一个线程的改动被另一个线程所覆盖。 synchronized 关键字有两种作用域： 1> 某个对象实例内，synchronized aMethod(){}关键字可以防止多个线程访问对象的synchronized...
谈谈synchronize关键字
04-30
Java中的synchronized关键字是一种用于实现线程同步的机制。当一个方法或代码块被声明为synchronized时，它就成为了一个“临界区”，只有一个线程能够进入该临界区，其他线程必须等待。 使用synchronized关键字可以...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值