并发编程之synchronized关键字

最新推荐文章于 2022-04-07 09:58:51 发布
最新推荐文章于 2022-04-07 09:58:51 发布
阅读量189 收藏
点赞数
分类专栏： 并发编程 文章标签： synchronized synchronized同步块 this锁 object锁 class锁
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pulong0748/article/details/88063574
版权

文章目录

synchronized关键字

一：简单介绍

之前我们写的大多数程序都是一个线程在操作，那么先来看一下下面这个例子：

public class UnsafeThreadCallDemo {
    private static int i = 0;
    public static class Mythread extends Thread{
        @Override
        public void run() {
            for (int j = 0; j < 1000; j++) {
                i++;
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Mythread t1 = new Mythread();
        Mythread t2 = new Mythread();
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("i最后的值是：" + i);
    }
}

我们从结果中可以发现在很多时候，i的值总是会小于2000，并不是我们以为的2000.因为在i++的时候可能t1线程和t2线程同时读取了i,并且做了++操作，导致了重复。所以我们必须保证多个线程对i进行操作的时候完全同步。即t1线程写入的时候，t2不能读也不能写。因此引出了synchonized关键字。

二：java同步块

Java中的同步块用synchronized关键字标记。Java中的同步块在某个对象上同步。在同一对象上同步的所有同步块只能同时在其中执行一个线程。尝试进入同步块的所有其他线程将被阻塞，直到同步块内的线程退出块。

该synchronized关键字可用于标记四种不同类型的块：

  1. 实例方法中的代码块
  2. 静态方法
  3. 实例方法
  4. 静态方法中的代码块

1.实例方法中的同步块

基本用法：

 public void add(int value){
    synchronized(this){
       this.count += value;   
    }
  }

案例：

现在有50个人去银行排队叫号，一共3个窗口，如何有条不紊的进行？

public class SynchronizedRunableDemo implements Runnable {
	// 叫号从1号开始
    private int index = 1;
	// 一天只服务200人
    private final static int MAX = 200;
	// 监视器
    private final Object MONITOR = new Object();

    @Override
    public void run() {

        while (true) {
            synchronized (MONITOR) {
                // 如果超过500 直接跳出
                if (index > MAX)
                    break;
                try {
                    // 线程停顿50毫秒
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread() + " 的号码是:" + (index++));
            }
        }
    }


public class Client {
    public static void main(String[] args) {
        final SynchronizedRunableDemo ticketWindow = new SynchronizedRunableDemo();
        Thread windowThread1 = new Thread(ticketWindow, "一号窗口");
        Thread windowThread2 = new Thread(ticketWindow, "二号窗口");
        Thread windowThread3 = new Thread(ticketWindow, "三号窗口");
        windowThread1.start();
        windowThread2.start();
        windowThread3.start();
    }
}

运行结果：

截取的部分结果：

Thread[三号窗口,5,main] 的号码是:59
Thread[三号窗口,5,main] 的号码是:60
Thread[三号窗口,5,main] 的号码是:61
Thread[三号窗口,5,main] 的号码是:62
Thread[三号窗口,5,main] 的号码是:63
Thread[三号窗口,5,main] 的号码是:64
Thread[一号窗口,5,main] 的号码是:65
Thread[二号窗口,5,main] 的号码是:66
Thread[二号窗口,5,main] 的号码是:67

…

Thread[一号窗口,5,main] 的号码是:200

在这个例子中，通过synchronized代码块来保证同一时间只有一个线程在synchronized同步的代码块中进行执行，也就是说synchronized中的代码块是以单线程执行的。所以最后输出来的一定是200，而如果不用synchronized进行同步，那么输出的结果也许就不止200了。

2.同步实例方法

基本用法：

 public synchronized void add(int value){
      this.count += value;
  }

案例依旧是银行取号

public class SynchronizedInstanceMethodDemo implements Runnable {
	
    private int index = 1;

    private final static int MAX = 200;

    @Override
    public void run() {
       while (true){
            if(!callNumber()){
                break;
            }
       }

    }
    // 叫号 同步实例方法
    private synchronized boolean callNumber(){
        if(index > MAX){
            return false;
        } 
        try {
            // 模拟取号耗时
            Thread.sleep(50);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread() + " 的号码是:" + (index++));
        return  true;
    }
}

运行结果：

Thread[二号窗口,5,main] 的号码是:176
…
Thread[二号窗口,5,main] 的号码是:198
Thread[二号窗口,5,main] 的号码是:199
Thread[二号窗口,5,main] 的号码是:200

3.同步静态方法

public class SynchronizedStaticInstanceDemo  {

    public static synchronized void addM1(){
        for(int i=1 ;i<5;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
        try {
            // 假设要执行5秒
            Thread.sleep(5_000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public static synchronized void addM2(){
        for(int i=6 ;i<10;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
        try {
            // 假设要执行5秒
            Thread.sleep(5_000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

public class Client {
    public static void main(String[] args) {
        Thread t1 = new Thread(new Runnable(){
            @Override
            public void run() {
                SynchronizedStaticInstanceDemo.addM1();
            }
        },"Thread-1");

        Thread t2 = new Thread(new Runnable(){
            @Override
            public void run() {
                SynchronizedStaticInstanceDemo.addM2();
            }
        },"Thread-2");

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

运行结果：

Thread-2:6
Thread-2:7
Thread-2:8
Thread-2:9
Thread-1:1
Thread-1:2
Thread-1:3
Thread-1:4

线程会在线程2执行完后等待5秒左右才会执行。

4.静态方法中的同步块

同样还是上面的计算案例：

 public static  void addM2(){
     // 只不过这里发生的写法变化
        synchronized (SynchronizedStaticInstanceDemo.class){
            for(int i=6 ;i<10;i++){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
            try {
                // 假设要执行5秒
                Thread.sleep(5_000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

三：this锁、class锁和object锁

1.syschronized(this)

this锁指的是锁住同步方法或者同步代码块所属的对象实例。synchronized以此作为监视器对象，我们通过同步代码块和同步方法来证实这一点：

public class SynchronizedThisLock {
    public static void main(String[] args) {

        ThisLock thisLock = new ThisLock();
        new Thread("Thread-T1") {
            @Override
            public void run() {
                thisLock.m1();
            }
        }.start();

        new Thread("Thread-T2") {
            @Override
            public void run() {
                thisLock.m2();
            }
        }.start();
    }
}

class ThisLock {
    // m1方法是一个同步方法
    public synchronized void m1() {
        try {
            System.out.println(Thread.currentThread().getName());
            Thread.sleep(5_000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
	
    // 而m2是一个普通方法，但是同步代码块的锁是this锁
    public void m2() {
        synchronized (this) {
            try {
                System.out.println(Thread.currentThread().getName());
                Thread.sleep(5_000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

运行结果：

Thread-T1
Thread-T2

在线程T1执行5秒之后，打印出T2，说明了synchronized同步方法的锁是this锁.此处的this指的就是thisLock。

2.synchronized(class)

static synchronized 表示锁住的是类的class对象，我们来验证一下：

public class SynchronizedStaticDemo {

    public synchronized static void m1() {
        System.out.println("m1 " + Thread.currentThread().getName());
        try {
            Thread.sleep(5_000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void m2() {
        synchronized (SynchronizedStaticDemo.class){
            System.out.println("m2 " + Thread.currentThread().getName());
            try {
                Thread.sleep(5_000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}


public class Client {
    public static void main(String[] args) {
        new Thread("T1") {
            @Override
            public void run() {
                SynchronizedStaticDemo.m1();
            }
        }.start();

        new Thread("T2") {
            @Override
            public void run() {
                SynchronizedStaticDemo.m2();
            }
        }.start();

    }
}

运行结果：

m1 T1
m2 T2

在打印出m1 T1 之后，停顿了5秒，才打印出m2 T2， 说明静态同步方法锁住的是类的class对象。

3. syschronized(Object)

通过创建不可变对象Object作为同步的监视器：

public class SynchronizedObjectLock {

    private final Object LOCK = new Object();

    public  void m1() {
        synchronized (LOCK){
            System.out.println("m1 " + Thread.currentThread().getName());
            try {
                Thread.sleep(5_000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
    public void m2() {
        synchronized (LOCK){
            System.out.println("m2 " + Thread.currentThread().getName());
            try {
                Thread.sleep(5_000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class Client {
    public static void main(String[] args) {
        SynchronizedObjectLock lock = new SynchronizedObjectLock();
        new Thread("T1") {
            @Override
            public void run() {
                lock.m1();
            }
        }.start();

        new Thread("T2") {
            @Override
            public void run() {
                lock.m2();
            }
        }.start();
    }
}

打印结果：

m1 T1
m2 T2

m1 T1在执行了5秒之后，才执行m2 T2.

4.同时使用this锁和class锁和Object锁

来测试一下同时使用3种锁：

public class ThreeLockDemo {

    private final Object LOCK = new Object();

    public void m1() {
        synchronized (this){
            System.out.println("m1 " + Thread.currentThread().getName());
            try {
                Thread.sleep(5_000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }

    public static void m2() {
        synchronized (ThreeLockDemo.class){
            System.out.println("m2 " + Thread.currentThread().getName());
            try {
                Thread.sleep(5_000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public  void m3() {
        synchronized (LOCK){
            System.out.println("m3 " + Thread.currentThread().getName());
            try {
                Thread.sleep(5_000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    
}

public class Client {
    public static void main(String[] args) {
        ThreeLockDemo threeLockDemo = new ThreeLockDemo();
        new Thread("T1") {
            @Override
            public void run() {
                threeLockDemo.m1();
            }
        }.start();

        new Thread("T2") {
            @Override
            public void run() {
                threeLockDemo.m2();
            }
        }.start();

        new Thread("T3") {
            @Override
            public void run() {
                threeLockDemo.m3();
            }
        }.start();
    }
}

运行结果：

m1 T1
m2 T2
m3 T3

上面3行同时打印出来，说明了每个线程之间的锁不一样，不需要等待其他线程执行完毕再次执行。

mindcarver
关注
专栏目录
Java并发编程-synchronized关键字详解及案例实战
program哲学
06-30 399
详细介绍synchronized关键字及相关应用案例实战（微服务注册中心为例）
JAVA 线程同步 synchronized
LEE
12-17 140
  synchronized public void methidA(){ for(int i = 0; i&lt; 100;i++){ System.out.println("methidA"); try{ Thread.sleep(5); }catch(Exception e){ } } } public void methi...
synchronized(二)
weixin_30354675的博客
04-09 80
package com.bjsxt.base.sync002;/** * 关键字synchronized取得的锁都是对象锁，而不是把一段代码（方法）当做锁， * 所以代码中哪个线程先执行synchronized关键字的方法，哪个线程就持有该方法所属对象的锁（Lock）， * * 在静态方法上加synchronized关键字，表示锁定.class类，类一级别的锁（独占.class类）。 * @au...
【错题本】关于下面一段代码，说法争取的是：public class Test { private synchronized void a( ) { } private void b( ) {
Smilence的博客
09-07 2146
6.关于下面一段代码，说法争取的是： public class Test { private synchronized void a( ) { } private void b( ) { synchronized (this) { } } private synchronized static voidC() { } private void d( ) { synchro...
M6(面试)-01-牛客网Java面试题集锦
FROZENcj的博客
04-07 4971
牛客网Java面试题集锦
一题引出“Java的synchronized锁问题”
喜欢前端的后端 MelodyJerry
04-14 9542
题目描述 关于下面一段代码，以下说法正确的是： public class Test { private synchronized void a() { } private void b() { synchronized (this) { } } private synchronized static void c() { } private void d() { synchronized (Test.cl
【Java并发编程】Synchronized关键字实现原理.doc
07-09
Java 并发编程 Synchronized 关键字实现原理 Synchronized 关键字是 Java 并发编程中最基本的同步机制，它可以保证线程安全，包括原子性、可见性和有序性。Synchronized 关键字可以修饰方法或代码块，使得在同一...
Java多线程并发编程 Synchronized关键字
08-30
Java中的`synchronized`关键字是多线程编程中用于实现线程同步的重要机制，它确保了在多线程环境下对共享资源的访问具有互斥性和可见性。这些特性使得`synchronized`成为解决并发问题的关键工具。 1. **同步锁机制*...
并发编程-synchronized关键字的使用
Angel-T的博客
04-25 245
前言 ​ 在工作中，我们经常会使用到并发编程，synchronized，volatile，ReentranLock，concurrent这几个关键字下的包相信大部分程序员都听说过，这些看似高深的代名词，很多人都不懂得如何去使用，滥用的结果往往都需要自己承担后果。在本章中，为大家讲解 synchronized 关键字的使用。 描述 ​ 我看过许多关于线程安全方面的书籍，上面对...
java多线程编程之Synchronized关键字详解
09-02
在Java多线程编程中，`Synchronized`关键字扮演着至关重要的角色，它主要用于实现线程之间的互斥访问，确保共享资源的安全性。本篇将深入解析`Synchronized`关键字，探讨其工作原理以及在实际应用中的注意事项。 一...
牛客刷题笔记--(java基础201-300)
想握住此生辽阔
12-15 1003
201 哪个类可用于处理 Unicode? (A) InputStreamReader BufferedReader Writer PipedInputStream InputStreamReader可以指定字符编码格式 A、 InputStreanReader的构造函数： InputStreamReader(InputStream in) 创建一个使用默认字符集的 InputStreamReader。 InputStreamReader(InputStream in, Charset cs) 创建
java输出线程时，显示Thread[main，5，main]，中括号里的三个值分别代表什么？
qq_37306041的博客
11-30 3391
1. 实例代码 public class SpinLockDemo { public static void main(String[] args) { Thread thread = Thread.currentThread(); System.out.println("当前线程名字："+ thread); } } 2.运行结果 3.说明 [线程名称, 线程优先级, 线程所属线程组] ...
Java 经典试题 （二）
热门推荐
幽客独往
10-05 1万+
**The following questions have appeared on actual exams.  Situational details (ie, names, locations, and quantities) have been changed to avoid copyright infringement. Memorize as many of these questi
【Java笔记】synchronized详解
vacherf的博客
06-06 1459
synchronized 同步原语 在多线程环境中，存在着共同操作访问一个对象类数据的情况，难免有数据不同步的情况出现。synchronized就是java内置修饰符专门来处理同步的。 对一个类、实例加锁，所有操作必须获取到锁才能进行。保证数据的同步。 使用场景大概分为四个：静态代码块、静态方法、非静态代码块、非静态方法。 其中，非静态方法锁定的是实例对象，在synchronized修...
深入理解Java并发编程：synchronized关键字详解
"并发编程原理学习：synchronized关键字文档" 在并发编程中，synchronized关键字是Java语言提供的一种重要的机制，用于确保多线程环境下的数据一致性与线程安全性。本文档将深入探讨synchronized的关键原理和用法，...
Java并发-对象锁，类锁
yayaqwl的博客
08-29 509
1. Java中加同步锁目前使用synchronized锁目前可以理解为下面两种锁，然后每种锁都可以加在代码上或者方法上（也可以按照方法锁和代码锁分类）第一种分类：1）类锁A : 只加在某块代码中，但是加锁的是类 synchronized(Sync.class)b: 加在静态方法上：public static synchronizedvoid test1() {...}2）对象锁A:  加在某块代...
java-synchronized方法
Ysh-uestc
04-05 214
  在java中，为了避免多个线程对同一资源访问操作时候的干扰脏读，可以用synchronized来同步方法class MyObject{ public synchronized void methodA(){ try{ System.out.println("begin methodA threadName=" + Thread.currentThread().getName...
java中的synchronized同步原理
心态决定一切
05-19 111
       synchronized关键字如果应用于方法，代表这个方法加锁，相当于不管哪个线程A每次运行到这个方法的时候，都要检测有没有其它正在使用这个方法的线程B(C或者D等)，有的话要等正在使用这个方法的线程B(C或者D等)运行完这个方法后在运行线程A，没有的话，直接运行。       它包括两种用法：synchronized方法和 synchronized 块。 1. synchron...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

mindcarver

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值