java多线程（4）synchronized的作用

最新推荐文章于 2024-09-07 14:57:30 发布
最新推荐文章于 2024-09-07 14:57:30 发布
阅读量321 收藏
点赞数
分类专栏： java并发 文章标签： java 多线程 并发 synchroniz 锁
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gagewang1/article/details/78597674
版权

在多线程并发的情况下，有时就涉及到对于同一资源的读写，如果不进行一些处理，容易出现数据混乱，结果和实际不一致等问题。java中可以使用synchronized关键字对资源锁定。

synchronized的用法

synchronized有2种用法：
1.修饰代码块，以某个对象为锁，锁的范围是指定的代码块。
2.修饰方法，其实也可以等价于修饰代码块，比如修饰普通方法：

synchronized void doxx(){
//.........
}

等价于

void doxx(){
    synchronized (this){
    //.........
    }
}

以当前实体为锁对象，整个方法都是在代码块中。也能修饰静态方法:

public class Test{
    static synchronized void doxx(){
    //.........
    }
}

等价于

public class Test{
    static void doxx(){
        synchronized (Test.class){
        //.........
        }
    }
}

synchronized 修饰代码块

先举一个反例demo：

import java.util.List;
import java.util.Random;

public  class Thread1 extends Thread{
    private List list;
    public Thread1(List list) {
        this.list=list;
    }
    @Override
    public void run() {
        try {
            for(int i=0;i<100;i++){
                Thread.sleep(10);//模拟处理一些业务,这样也更容易重现问题
                int randon = new Random().nextInt();
                list.add(randon);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
    public static void main(String[] args) throws InterruptedException {
        List list = new ArrayList<>(1000);
        Thread1 t1 = new Thread1(list);
        t1.start();
        Thread1 t2 = new Thread1(list);
        t2.start();
        t1.join();
        t2.join();
        System.out.println("size="+list.size());
    }

执行结果：

size=162

这个结果是不确定，每次执行都可能不一样。demo里启动了2个线程，每个执行100次，按理list的数据量应该会是200个。这个就是本文开始提到的，多个线程读写同一个对象时，发生了数据异常。那么我们再用synchronized对demo进行小小的改造。

import java.util.List;
import java.util.Random;

public  class Thread1 extends Thread{
    private List list;
    public Thread1(List list) {
        this.list=list;
    }
    @Override
    public void run() {
        try {
            for(int i=0;i<100;i++){
                Thread.sleep(10);//模拟处理一些业务,这样也更容易重现问题
                int randon = new Random().nextInt();
                synchronized (list) {//就只改这个地方
                    list.add(randon);
                }

            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

main方法保持不变，结果如下：

size=200

可见使用synchronized关键字后，代码的执行结果恢复了正常。

synchronized修饰方法

import java.util.List;
import java.util.Random;

public  class Thread1 extends Thread{
    private List list;
    public Thread1(List list) {
        this.list=list;
    }
    public synchronized void  run() {
        try {
            for(int i=0;i<100;i++){
                Thread.sleep(10);//模拟处理一些业务,这样也更容易重现问题
                int randon = new Random().nextInt();
                list.add(randon);

            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

main方法不变，执行结果：

size=150

这是很多人开始接触多线程时，会出现的错误，明明对run方法用了synchronized 关键字怎么出来的结果是不对的。根据上面提到的我们把代码转变一下：

import java.util.List;
import java.util.Random;

public  class Thread1 extends Thread{
    private List list;
    public Thread1(List list) {
        this.list=list;
    }
    public  void  run() {
        try {
            synchronized(this){//把synchronized改到这个地方
                for(int i=0;i<100;i++){
                    Thread.sleep(10);//模拟处理一些业务,这样也更容易重现问题
                    int randon = new Random().nextInt();
                    list.add(randon);
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

synchronized用在this上，所以t1.start()锁定的是t1，t2.start()锁定的是t2，2者锁定的对象不同自然就没有相应的效果。

那是不是synchronized用在方法上就没有作用呢？当然不会，先看下面的例子：

import java.util.Random;

public  class Thread1 extends Thread{
    private SyncList list;
    public Thread1(SyncList list) {
        this.list=list;
    }
    public  void  run() {
        try {
            for(int i=0;i<100;i++){
                Thread.sleep(10);//模拟处理一些业务,这样也更容易重现问题
                int randon = new Random().nextInt();
                list.addList(randon);//注意这里
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
import java.util.ArrayList;
import java.util.List;

public class SyncList<E>{

    private List<E> list;

    public SyncList(List list) {
        this.list = list;
    }

    public void addList(E obj){
        list.add(obj);
    }
    public List<E> getList() {
        return list;
    }
}

    public static void main(String[] args) throws InterruptedException {
        SyncList list = new SyncList(new ArrayList<>(1000));
        Thread1 t1 = new Thread1(list);
        t1.start();
        Thread1 t2 = new Thread1(list);
        t2.start();
        t1.join();
        t2.join();
        System.out.println("size="+list.getList().size());
}

执行结果：

size=161

修改一下SyncList：

import java.util.ArrayList;
import java.util.List;

public class SyncList<E>{

    private List<E> list;

    public SyncList(List list) {
        this.list = list;
    }

    public synchronized void addList(E obj){//仅在这里加上synchronized 
        list.add(obj);
    }
    public List<E> getList() {
        return list;
    }
}

执行结果：

size=200

这个就是synchronized用在方法上的一个例子，锁定的对象都是同一个SyncList，所以最终结果是正确的。因此synchronized使用上很重要的一点，是保障多个线程锁定的对象要一致。

异常释放锁

public  class Thread1 extends Thread{
    private Object lock;
    public Thread1(Object lock) {
        this.lock=lock;
    }
    public  void  run() {
        try {
            synchronized (lock) {
                for(int i=5;i>-1;i--){
                    System.out.println(Thread.currentThread().getName()+":"+i);
                    Thread.sleep(200);
                    int j= 100/i;
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
    public static void main(String[] args) throws InterruptedException {
        Object lock = new Object();
        for(int i=0;i<2;i++){
            Thread1 t1 = new Thread1(lock);
            t1.start();
            t1.join();
            Thread.sleep(10);
        }
}

执行结果：

Thread-0:5
Thread-0:4
Thread-0:3
Thread-0:2
Thread-0:1
Thread-0:0
Exception in thread "Thread-0" java.lang.ArithmeticException: / by zero
    at Thread1.run(Thread1.java:12)
Thread-1:5
Thread-1:4
Thread-1:3
Thread-1:2
Thread-1:1
Thread-1:0
Exception in thread "Thread-1" java.lang.ArithmeticException: / by zero
    at Thread1.run(Thread1.java:12)

可以看到由于Thread-0先获取锁，Thread-1一直处于等待状态，Thread-0一直执行到i=0时，程序发生异常，锁被释放。Thread-1就获得了锁开始执行。

总结

1.synchronized可以修饰方法或者代码块。
2.尽量使用代码块以及减少代码块的范围，有利于提高程序运行效率。
3.要注意锁定的对象是否一致。

中华雪碧
关注
专栏目录
Java多线程同步Synchronized深入解析
12-22
　1、在系统中对访类要使用多线程进行访问； 　2、在该类中有 类变量，或者是 在类的方法中有访问公共资源（如一个外部文件的读写）。 　同步锁锁定的内容是什么？ 　无论你将Synchronized加在方法前还是加在...
Java多线程中使用synchronized说明
12-22
在Java多线程编程中，`synchronized`有多种用法，包括修饰实例方法、静态方法以及作为代码块来锁定特定的对象引用。 1. **修饰实例方法**： 当`synchronized`关键字用于实例方法时，它会对该实例对象加锁。这意味...
JAVA多线程-synchronized的作用
King8611的博客
07-16 267
在多线程运行中，两个程序如果同时调用一个资源，会容易出现错误，如下面代码: 一个图书管理账单。 class Booking{ private int amount=90; public void sale(int num){ if(num&lt;=amount){ System.out.println(" 预定 "+num+" 件 "); try{ Thread....
Java多线程中【 synchronized 】关键字的作用！
22
03-07 384
Java多线程中[ synchronized ]关键字的作用！
Java关键字之synchronized详解【Java多线程必备】
Mr.绵羊的知识星球
04-05 6296
1. synchronized详解 2. synchronized使用注意事项和案例
Java多线程之synchronized的使用技巧
MaybeUnforgiven的博客
06-19 358
在使用synchronized的时候，我们有时只是希望防止多个线程同时访问方法内部的部分代码而不是防止其访问整个方法，通过这种方式分离出来的代码我们成为临界区(critical section)，如下列代码所示：
Java线程基础之Synchronized
weixin_43326254的博客
08-08 400
什么是Synchronized，Synchronized的作用
Java 多线程synchronized关键字详解(六)
09-03
Java中的`synchronized`关键字是多线程编程中的一个重要概念，用于控制并发访问共享资源，以避免数据不一致和竞态条件。在这个问题中，我们将深入理解`synchronized`的关键字用法，包括同步方法和同步块。 1. **...
浅析Java多线程同步synchronized
08-27
Java多线程同步synchronized Java多线程同步synchronized是Java编程语言中最基本的同步机制之一。它通过锁机制来实现多线程之间的同步，确保多个线程访问共享资源时的安全性。 在Java中，synchronized关键字可以...
Java多线程（Synchronized+Volatile+JUC 并发工具原理+线程状态+CAS+线程池）
06-21
Java 多线程（Synchronized+Volatile+JUC 并发工具原理+线程状态+CAS+线程池） Java 多线程是 Java 语言中的一种并发编程机制，允许程序同时执行多个线程，以提高程序的执行效率和响应速度。 Java 多线程机制提供了...
JAVA多线程编程--synchronized 关键字
m0_56161893的博客
02-10 391
JAVA多线程编程的一个重点，synchronized 关键字；掌握用法和理解底层原理
synchronized
最新发布
m0_74064008的博客
09-07 793
变量的值会被加载到线程的工作内存中，但此时还未赋值到线程工作内存的副本中。偏向锁使得一个线程对一个对象的锁有偏向，默认情况下，锁会偏向于第一个获取它的线程。并发编程时，当一个线程对共享变量操作一半时，另外的线程也可能开始对共享变量进行操作，从而干扰前一个线程的操作。将读取到的变量值从线程的工作内存赋值给工作内存的变量副本中。依然会发生重排序，但有同步代码块，可以保证一个线程执行同步代码块中的代码，保证有序性。是Java中一种基本的同步机制，通过锁的升级过程和一系列的优化手段，可以适应不同的并发场景。
Java多线程 volatile 作用与总结以及与synchronized关系
Java持续实践
09-06 362
文章目录volatile的两点作用volatile与synchronized 的关系volatile总结 volatile的两点作用 保证可见性: 读取一个volatile 变量之前, 需要先使相应的本地缓存失效. 这样就必须到主内存读取最新的值,把读取到的最新的值, 放到子线程的工作内存中去. 写一个volatile 修饰的属性, 会立即刷入到主内存. 禁止指令重排: 解决单例双重锁乱序问题. 关于指令重排序,之前写的如下这篇文章中有提到指令重排序问题. https://javaweixin6.blo
java的synchronized 关键字详解
m0_57659908的博客
04-13 1816
java的synchronized 关键字详解，介绍了synchronized 的原理，synchronized 的优化，即偏向锁，轻量级锁，自旋锁，锁消除，锁加重
java多线程-Synchronized关键字详解
lijianbiao0的博客
05-30 731
Synchronized关键字开篇定义作用应用场景原理具体使用使用方式特别注意其他控制并发 / 线程同步方式Lock、ReentrantLock简介区别Compare And Swap（CAS）定义：原理优点典型应用：AtomicInteger 开篇 在Java中，有一个常被忽略 但 非常重要的关键字Synchronized 今天，我将详细讲解 Java关键字Synchronized的所有知识，希...
JAVA多线程synchronized关键字不起作用
LMR的博客
05-23 1万+
今天在使用synchronized关键字来实现共享变量线程安全时，结果不起作用（自己犯了小错误。。。）。这实在有点颠覆我的三观，先贴上代码： public class VolatileTest {//volatile关键字不能保证遍历的线程安全性 // Object o = new Object();//线程不安全？？ public volatile int counts ...
synchronized在多线程中的使用
顶峰
07-01 516
先看一个例子： //模仿火车售票系统，假设有4个售票点同时售票，我们可以把四个售票点定义为四个独立线程 class Test {  public static void main(String[] args)   {   TestThread tt=new TestThread();   new Thread(tt).start();        //每一个售票点定义为一个
对RandomList进行深复制
08-12 1433
复制一个链表简单，甚或shenfuz
Java中synchronized同步锁四种用法及作用范围
热门推荐
我是guyue，guyue就是我O(∩_∩)O
12-17 1万+
  Java中synchronized同步锁用法及作用范围 - 在梅边的专栏 - CSDN博客 https://blog.csdn.net/yx0628/article/details/79086511   Java中synchronized同步锁用法及作用范围       Java 中的 synchronized 关键字可以在多线程环境下用来作为线程安全的同步锁。本文主要对 syn...
Java多线程：Synchronized同步类方法解析
总结来说，`synchronized`关键字在Java多线程编程中起到至关重要的作用，它提供了一种机制来保护共享资源不受并发访问的影响，从而避免数据不一致性和线程安全问题。无论是同步实例方法还是静态方法，都需要注意锁的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值