Java的synchronized同步

最新推荐文章于 2022-11-16 10:28:21 发布
最新推荐文章于 2022-11-16 10:28:21 发布
阅读量160 收藏
点赞数
分类专栏： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011676300/article/details/80779360
版权

完整代码

前言

　　非线程安全会出现在多个线程同时对同一个对象的实例变量进行并发访问时发生，产生的后果就是脏读，也就是读取到的数据其实是被更改过的，而线程安全就是获得的实例变量是经过同步处理过的，不会出现脏读的情况．
　　本问主要讲解使用synchronized关键字实现同步，Java中还可以使用ReentrantLock同步，这将在另一篇文章中进行讲解Java的Lock同步．

synchronized同步方法

返回目录

非线程安全的情况

package org.sync;

import java.util.Set;

public class AddSync {

    private String name;

    public static void main(String[] args) {
        AddSync sync = new AddSync();

        Thread1 thread1 = new Thread1(sync,"aaa");
        Thread1 thread2 = new Thread1(sync,"bbb");

        thread1.start();
        thread2.start();

    }
    public void  setName(String name) {

        this.name = name;
        try {
        //模拟长时间的任务
            Thread.sleep(500);
        } catch (Exception e) {
            // TODO: handle exception
        }

        System.out.println(Thread.currentThread().getName() + "  显示的　name = " + this.name);
    }
}

class Thread1 extends Thread{

    AddSync  sync;
    private String name;

    public Thread1(AddSync sync, String name) {
        super();
        this.sync = sync;
        this.name = name;
    }

    @Override
    public void run() {     
        System.out.println(Thread.currentThread().getName() + "  写入的　name = " + name);
        sync.setName(name);
    }   
}

输出
可以看出来，写入的name和显示的不一样，两个线程并发访问了setName();方法，导致出现非线程安全．

Thread-0 写入的 name = aaa
Thread-1 写入的 name = bbb
Thread-0 显示的 name = bbb
Thread-1 显示的 name = bbb

在setName()上加上synchronized进行同步

synchronized public void  setName(String name) {

        this.name = name;
        try {
            Thread.sleep(500);
        } catch (Exception e) {
            // TODO: handle exception
        }

        System.out.println(Thread.currentThread().getName() + " 显示的 name = " + this.name);
    }

输出
加上synchronized，程序对方法setName()进行了同步处理，每次只能有一个线程进行访问，此时不会再出现线程不安全问题．

Thread-1 写入的 name = bbb
Thread-0 写入的 name = aaa
Thread-1 显示的 name = bbb
Thread-0 显示的 name = aaa

synchronized是对象锁

验证synchronized是对象锁
下面创建一个例子
１．多个线程访问单个实例
２．多个线程访问不同的实例

package org.sync;
/**
 * 验证多个对象多个锁
 * @author lgj
 *
 */
public class ObjSync extends Thread {

    private String name;
    public static void main(String[] args) {

        //多个线程访问同一对象
        System.out.println("多个线程访问同一对象");
        //创建一个对象
        ObjSync obj1 = new ObjSync("aaa");
        Thread[] thread = new Thread[5];
        //创建5个线程
        for(int i = 0;i<5;i++) {
            thread[i] = new Thread(obj1);
        }
        //启动线程
        for(int i = 0;i<5;i++) {
            thread[i].start();
        }
        //等待上面的程序执行完
        try {
            Thread.sleep(2000);
        } catch (Exception e) {
            // TODO: handle exception
        }
        //多个线程访问不同对象
        System.out.println("多个线程访问不同对象");
        ObjSync[] obj = new ObjSync[5];
        //创建5个对象
        for(int i = 0;i<5;i++) {
            obj[i] = new ObjSync(""+i);
        }
        //创建5个线程
        Thread[] thread1 = new Thread[5];
        for(int i = 0;i<5;i++) {
            thread1[i] = new Thread(obj[i]);
        }
        for(int i = 0;i<5;i++) {
            thread1[i].start();
        }   
    }
    public ObjSync(String name) {
        super();
        this.name = name;
    }

    @Override
    synchronized public void run() {
        System.out.println("线程：" + Thread.currentThread().getName() + "  实例类：" + this.name + "开始执行线程");
        try {
            Thread.sleep(200);
        } catch (Exception e) {
            // TODO: handle exception
        }
        System.out.println("线程：" + Thread.currentThread().getName() + "  实例类：" + this.name + "开始退出线程");
    }   

}

１．多个线程访问单个实例
　　每一个线程都要等待其他获得锁的线程执行完后才能执行．
２．多个线程访问不同的实例
　　由于是不同的对象，因此所有的线程都是同步执行，互不影响．
由以上可知，synchronized同步非静态方法是对象锁，不同的对象互不影响．

多个线程访问同一对象
线程：Thread-1  实例类：aaa开始执行线程
线程：Thread-1  实例类：aaa开始退出线程
线程：Thread-2  实例类：aaa开始执行线程
线程：Thread-2  实例类：aaa开始退出线程
线程：Thread-5  实例类：aaa开始执行线程
线程：Thread-5  实例类：aaa开始退出线程
线程：Thread-4  实例类：aaa开始执行线程
线程：Thread-4  实例类：aaa开始退出线程
线程：Thread-3  实例类：aaa开始执行线程
线程：Thread-3  实例类：aaa开始退出线程
多个线程访问不同对象
线程：Thread-11  实例类：0开始执行线程
线程：Thread-13  实例类：2开始执行线程
线程：Thread-14  实例类：3开始执行线程
线程：Thread-15  实例类：4开始执行线程
线程：Thread-12  实例类：1开始执行线程
线程：Thread-11  实例类：0开始退出线程
线程：Thread-13  实例类：2开始退出线程
线程：Thread-14  实例类：3开始退出线程
线程：Thread-15  实例类：4开始退出线程
线程：Thread-12  实例类：1开始退出线程

synchronized重入锁

在上面的基础上增加两个方法

/**
 * 测试可重入锁
 */
synchronized public void  method1() {
    System.out.println("method1执行");
    method2();
}
synchronized public void method2() {
    System.out.println("method2执行");
}
//run()方法
@Override
public void run() {
    method1();
}
测试
ObjSync thObjSync = new ObjSync("aaa");
thObjSync.start();

输出
method1执行
method2执行

在method1()中，线程继续访问同步方法method2().并且成功访问．假如锁是不可重入的，那么线程访问method2()将会失败，因为没有获得锁．这说明synchronized的锁是可重入的．

脏读

当写进行了同步，但是读没有进行同步，有可能就会出现读取的值与写入的值不一致．发生脏读的情况是读取实例变量时，此值已经被其他线程改过了．

出现异常，锁自动释放

当出现异常时，线程持有的对象锁自动释放，并且该线程结束执行．

同步不具有继承性

当子类重写父类的方法，并且父类中的方法已经使用synchronized进行同步，如果子类重写的方法也需要实现同步，仍需要加上synchronized．

synchronized同步方法的问题

synchronized同步方法会降低程序的效率．
如下的一个同步方法，假如只有task10ms();需要进行同步，当有10个线程进行访问时，因为每个线程只有获得锁之后才能执行，因此总的运行时间大约是110ms * 10 = 1100ms.
下一节使用synchronized同步语句块来解决这个问题．

synchronized public void method(){
    //模拟一个100ms的任务
    task100ms();
    //继续执行一个10ms的任务
    task10ms();
}

synchronized同步语句块

返回目录
继续上节的问题
这回只对task10ms();进行同步，当有10个线程进行访问时，task100ms();可以同时执行，而task10ms();需要获得锁之后才能执行，因此总的执行时间是100ms+10*10ms=200ms，效率提高了很多．

 public void method(){
    //模拟一个100ms的任务
    task100ms();
    //继续执行一个10ms的任务
    synchronized（this）{
        task10ms();
    }
}

synchronized(this)同步语句块获得的是对象锁

package org.sync.block;
/**
 * 验证synchronized同步语句块获得的是对象锁
 * @author lgj
 *
 */
public class BlockSync {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        MyBlockSync myBlockSync = new MyBlockSync();

        MyThread1 th1 = new MyThread1(myBlockSync);
        MyThread2 th2 = new MyThread2(myBlockSync);
        MyThread3 th3 = new MyThread3(myBlockSync);
        MyThread4 th4 = new MyThread4(myBlockSync);

        th1.start();
        th2.start();
        th3.start();
        //th4.start();
    }

}

class MyBlockSync{
    Object obj = new Object();
    //method1是同步方法
    synchronized public void method1() {
        System.out.println("执行同步方法－method1");
        System.out.println("+++进入同步方法－method１");
        try {
            Thread.sleep(2000);
        } catch (Exception e) {
            // TODO: handle exception
        }
        System.out.println("---退出同步方法－method1\r\n");
    }
    //method２是同步语句块
     public void method2() {
         System.out.println("执行同步代码块－method2");
         synchronized(this) {
             try {
                System.out.println("+++进入同步块－method2");
                Thread.sleep(500);
            } catch (Exception e) {
                // TODO: handle exception
            }
         }  
         System.out.println("---退出同步代码块－method2\r\n");
    }
    //method３是同步语句块
     public void method3() {
         System.out.println("执行同步代码块－method3");
         synchronized(this) {
             try {
                 System.out.println("+++进入同步块－method3");
                Thread.sleep(500);
            } catch (Exception e) {
                // TODO: handle exception
            }
         }
         System.out.println("---退出同步代码块－method3\r\n");
    }

}
/**
 * 线程类
 * @author lgj
 *
 */
class MyThread1 extends Thread{
    MyBlockSync  myBlockSync;   
    public MyThread1(MyBlockSync myBlockSync) {
        super();
        this.myBlockSync = myBlockSync;
    }
    @Override
    public void run() {
        //调用method1
        myBlockSync.method1();
    }   

}
class MyThread2 extends Thread{

    MyBlockSync  myBlockSync;   
    public MyThread2(MyBlockSync myBlockSync) {
        super();
        this.myBlockSync = myBlockSync;
    }
    @Override
    public void run() {
        //调用method２
        myBlockSync.method2();
    }   

}
class MyThread3 extends Thread{

    MyBlockSync  myBlockSync;   
    public MyThread3(MyBlockSync myBlockSync) {
        super();
        this.myBlockSync = myBlockSync;
    }
    @Override
    public void run() {
        //调用method３
        myBlockSync.method3();
    }   
}

输出

执行同步方法－method1
+++进入同步方法－method１
执行同步代码块－method3
执行同步代码块－method2
---退出同步方法－method1

+++进入同步块－method2
---退出同步代码块－method2

+++进入同步块－method3
---退出同步代码块－method3

method1()睡眠了2000ms,线程２和３都是等其执行完才获得锁，因此synchronized(this)同步语句块和synchronized同步方法获得的都是对象锁．

将任意对象作为对象监视器synchronized(非this对象)

上面是使用synchronized(this)来同步代码块，Java还支持非this对象作为对象监视器来实现同步．

Object obj = new Object();
public void func(){
    synchronized(obj){
        //语句块
    }
｝

在上面的例子中添加如下代码

//创建一个对象作为对象监视器
Object obj = new Object();
//添加两个同步语句块，使用非this对象作为对象监视器
//method4是同步语句块
 public void method4() {
         System.out.println("执行同步代码块－method4");
         synchronized(obj) {
             try {
                 System.out.println("+++进入同步块－method4");
                Thread.sleep(2000);
            } catch (Exception e) {
                // TODO: handle exception
            }
         }
         System.out.println("---退出同步代码块－method4\r\n");
    }
    //method5是同步语句块
 public void method5() {
         System.out.println("执行同步代码块－method5");
         synchronized(obj) {
             try {
                 System.out.println("+++进入同步块－method5");
                Thread.sleep(2000);
            } catch (Exception e) {
                // TODO: handle exception
            }
         }
         System.out.println("---退出同步代码块－method5\r\n");
    }
//添加两个线程

class MyThread4 extends Thread{

    MyBlockSync  myBlockSync;   
    public MyThread4(MyBlockSync myBlockSync) {
        super();
        this.myBlockSync = myBlockSync;
    }
    @Override
    public void run() {
        //调用method4
        myBlockSync.method4();
    }   
}
class MyThread5 extends Thread{

    MyBlockSync  myBlockSync;   
    public MyThread5(MyBlockSync myBlockSync) {
        super();
        this.myBlockSync = myBlockSync;
    }
    @Override
    public void run() {
        //调用method4
        myBlockSync.method5();
    }   
}
//测试
//非this对象作为同步监视器
MyThread4 th4 = new MyThread4(myBlockSync);
MyThread5 th5 = new MyThread5(myBlockSync);
th4.start();
th5.start();

输出

执行同步代码块－method3
执行同步代码块－method4
+++进入同步块－method4
执行同步代码块－method5
---退出同步方法－method1

+++进入同步块－method3
---退出同步代码块－method4

+++进入同步块－method5
---退出同步代码块－method3

+++进入同步块－method2
---退出同步代码块－method2

---退出同步代码块－method5

从以上输出可以看出：
１．synchronized(非this对象)获得的锁不是对象锁，与synchronized(this)和synchronized同步方法不互相阻塞．
２．synchronized(非this对象)，如果对象为同一个对象，那么同一时间只能有一个线程能够访问．

静态方法使用synchronized

在上述例程中添加如下代码　

//静态同步方法
//method6是静态同步方法
synchronized public static void method6() {
    System.out.println("+++进入静态同步方法－method6");
    try {
        Thread.sleep(2000);
    } catch (Exception e) {
        // TODO: handle exception
    }
    System.out.println("---退出静态同步方法－method6\r\n");
}

//method7是静态同步方法
synchronized public static void method7() {
    System.out.println("+++进入静态同步方法－method7");
    try {
        Thread.sleep(2000);
    } catch (Exception e) {
        // TODO: handle exception
    }
    System.out.println("---退出静态同步方法－method7\r\n");
}
//线程
class MyThread6 extends Thread{

    MyBlockSync  myBlockSync;   
    public MyThread6(MyBlockSync myBlockSync) {
        super();
        this.myBlockSync = myBlockSync;
    }
    @Override
    public void run() {
        //调用method4
        myBlockSync.method6();
    }   
}
class MyThread7 extends Thread{

    MyBlockSync  myBlockSync;   
    public MyThread7(MyBlockSync myBlockSync) {
        super();
        this.myBlockSync = myBlockSync;
    }
    @Override
    public void run() {
        //调用method4
        myBlockSync.method7();
    }   
}
//测试
//静态同步方法
MyThread6 th6 = new MyThread6(myBlockSync);
MyThread7 th7 = new MyThread7(myBlockSync);

//静态同步方法
th6.start();
th7.start();

输出

执行同步代码块－method2
执行同步方法－method1
+++进入同步方法－method１
执行同步代码块－method4
+++进入同步块－method4
执行同步代码块－method3
执行同步代码块－method5
+++进入静态同步方法－method6
---退出同步方法－method1

+++进入同步块－method5
---退出静态同步方法－method6

+++进入静态同步方法－method7
---退出同步代码块－method4

+++进入同步块－method3
---退出同步代码块－method3

+++进入同步块－method2
---退出同步代码块－method2

---退出同步代码块－method5

---退出静态同步方法－method7

从以上可以看出
１．静态同步方法获得的是类锁
２．（静态同步方法），（非静态同步方法和 synchronized(this) 同步语句块）， synchronized(非this对象)这三者获取的都是不同的锁，不会互相阻塞．

查看线程死锁

public void method2() {
     System.out.println("执行同步代码块－method2");
     synchronized(this) {
         System.out.println("+++进入同步块－method2");
        while(true);
     }  
}
//method３是同步语句块
 public void method3() {
     System.out.println("执行同步代码块－method3");
     synchronized(this) {
         System.out.println("+++进入同步块－method3");
         while(true) {
         }
     }  
}

执行　jps　命令，得到运行的线程PID为17055

再执行　jstack -l 17055，便可以获得结果，清晰地指明了哪个类的哪个方法出现死锁．

这里写图片描述
这里写图片描述

皮蛋瘦肉
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java同步机制总结--synchronized
leo_faith
03-30 159
不久前用到了同步，现在回过头来对JAVA中的同步做个总结，以对前段时间工作的总结和自我技术的条理话。JAVA中synchronized关键字能够作为函数的修饰符，也可作为函数内的语句，也就是平时说的同步方法和同步语句块。假如再细的分类，synchronized可作用于instance变量、object reference（对象引用）、static函数和class literals(类名称字面常量)...
Java同步之synchronized
守得云开见明月
02-04 1万+
Java中可以使用关键字synchronized进行线程同步控制，实现关键资源顺序访问，避免由于多线程并发执行导致的数据不一致性等问题。synchronized的原理是对象监视器（锁），只有获取到监视器的线程才能继续执行，否则线程会等待获取监视器。Java中每个对象或者类都有一把锁与之相关联，对于对象来说，监视的是这个对象的实例变量，对于类来说，监视的是类变量（一个类本身是类Class的对象，所以
java之Synchronized同步
qq_35006660的博客
10-31 99
java多线程下如何保证共享数据安全，如何保证数据的顺序访问问题，这就需要我们在书写程序代码时需要关注的一个点，在单体java服务中使用Synchronized关键字保证数据同步也是很常...
Java同步synchronized
joedan0104的专栏
06-25 270
一. synchronized是什么？ synchronized是Java的一个关键字，synchronized依赖于JVM具体实现。 synchronized的作用 synchronized也称为同步锁。synchronized是一种独占锁。 synchronized的两大功能： 内存可见性 操作原子性 什么是内存可见性？ 可见性是指当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。 可参考《Java内存分级和指令重排序》。volatile也可实现内存
java使用synchronized进行同步
u011277123的博客
04-20 440
java探讨 2017-04-10 04:32 提到同步就离不开多线程——即多线程抢占资源时要保证线程的安全。 简单例子：如有一个全局变量int sum=1，有两个（A、B）线程对其进行操作，他们获取该资源时都是sum=1，而A线程对其进行加1写回去变成sum=2，如我们希望的是B线程对其也进行加1的话为sum=3，但是因为B线程获取到时是sum=1，所以进行加1写回去也是sum=
基于Java synchronized同步锁实现线程交互.pdf
最新发布
12-31
"基于Java synchronized同步锁实现线程交互" Java多线程能够提高CPU利用效率，但也容易造成线程不安全、线程死锁等问题。Java synchronized同步锁可以保证同一时刻只有一个线程操作同一资源，使用wait()、notify()...
简单了解Java synchronized关键字同步
08-25
Java synchronized关键字同步详解 Java 中的 synchronized 关键字是用于实现线程同步的重要机制。下面我们将详细介绍 synchronized 关键字的使用方法和原理。 synchronized 关键字的作用 synchronized 关键字可以...
java synchronized同步静态方法和同步非静态方法的异同
08-31
在Java编程语言中，`synchronized`关键字是用于实现线程同步的重要机制，它确保了在多线程环境下，对共享资源的访问是安全的。本文将深入探讨`synchronized`关键字在同步静态方法和非静态方法上的异同。 首先，`...
Java多线程synchronized同步方法详解
08-24
主要介绍了Java多线程synchronized同步方法详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
详细解读java同步之synchronized解析
08-26
【Java同步之synchronized解析】 Java中的`synchronized`关键字是实现多线程同步的重要机制，它确保了在并发环境中对共享资源的访问是线程安全的。以下是对`synchronized`的详细解读： ### 1. synchronized的特性 ...
java同步机制 synchronized
xiang_fu的博客
09-06 58
JAVA中synchronized关键字能够作为函数的修饰符，也可作为函数内的语句，也就是平时说的同步方法和同步语句块。假如再细的分类，synchronized可作用于instance变量、object reference（对象引用）、static函数和class literals(类名称字面常量)身上。 在进一步阐述之前，我们需要明确几点： A．无论synchronized关键字加在方...
Java 线程阻塞、中断及优雅退出
chengmaoning的专栏
06-12 1万+
线程阻塞一个线程进入阻塞状态的原因可能如下（已排除Deprecated方法）：sleep()sleep()使当前线程进入停滞状态（阻塞当前线程），让出CUP的使用、目的是不让当前线程独自霸占该进程所获的CPU资源，以留一定时间给其他线程执行的机会;当在一个Synchronized块中调用Sleep()方法是，线程虽然休眠了，但是对象锁并没有被释放，其他线程无法访问这个对象（即使睡着也持有对象锁）。w
synchronized和ReentrantLock异常退出时的锁处理
BitsPlayer
04-06 2411
在JDK5.0之前，在协调对共享对象的访问时可以使用的机制只有synchronized和volatile. JDK5.0新增了ReentrantLock，作为一种可选的高级功能．ReentrantLock必须要在finally中unlock(), 否则,如果在被加锁的代码中抛出了异常,那么这个锁将会永远无法释放. synchronized就没有这样的问题, 遇到异常退出时,会释放掉已经获得的锁.
synchronized使用的正确姿势
蜕变的快乐
07-28 1612
synchronized关键字在java中是用作线程同步的，保障同步区代码的正确执行，同一时间仅有一个线程进入同步区，其原理是使用锁技术，通过竞争，得到锁的线程执行同步区代码，未得到锁的线程自旋、阻塞等待。下面分为四个部分来对synchronized进行分析： 三种使用方式 实例讲解 单例中的使用 原理浅析 请您站稳扶好，开车了… 三种使用方式 分别是修饰实例方法，修饰静态方法，修饰代码块...
synchronized（偏向锁和轻量级锁）（TODO）
anlao4870的博客
07-07 841
synchronized 　　JDK1.6对synchronized进行了各种优化，性能已经和ReentrantLock差不多了。 　　Java中的每一个对象都可以作为锁。具体表现为以下3种形式。 对于普通同步方法，锁是当前实例对象。 对于静态同步方法，锁是当前类的Class对象。 对于同步方法块，锁是Synchonized括号里配置的对象。 　　JVM基于进入和退出...
关于java线程的一些特性 启动 中断 及如何退出
killermyth的专栏
01-11 885
关于java线程的一些特性 启动 中断 及如何退出
JAVA中同步锁synchronized的使用
qq_35321791的博客
11-16 2812
JAVA中同步锁synchronized的使用
深入理解Java并发之synchronized实现原理
热门推荐
zejian的博客
06-04 40万+
【版权申明】未经博主同意，谢绝转载！（请尊重原创，博主保留追究权） http://blog.csdn.net/javazejian/article/details/72828483 出自【zejian的博客】 关联文章： 深入理解Java类型信息(Class对象)与反射机制 深入理解Java枚举类型(enum) 深入理解Java注解类型(@Annotation) 深...
java，Synchronized同步方法实例（一）
Top5软件工程硕士，先后在京东、字节从事多年Java后端开发、实时和离线大数据开发
09-30 787
是线程获取对象的锁，且该线程执行对象所属类中的同步方法！ 当然线程也是对象，也有锁，锁只是对象的一个标志位。 哪个线程获得了SynClass的对象锁,则哪个线程进入同步方法中执行 public class WaitTest1 { public static void main(String[] args) { SynClass synClass = new SynC...
java线程同步synchronized
07-27
Java中的线程同步是通过关键字synchronized来实现的。synchronized关键字可以应用在方法或代码块上，用于实现线程安全。当一个线程获取了某个对象的锁，其他试图获取该对象锁的线程将被阻塞，直到该线程释放锁。 在...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值