Java并发之synchronized使用

时间  2019-11-24
标签 java 并发 synchronized 使用 栏目 Java 繁體版
原文   原文链接

synchronized，是Java语言的关键字，读['siŋkrənaizd]，当它用来修饰一个方法或者一个代码块的时候，可以保证在同一时刻最多只有一个线程执行该段代码。编程

1、Java为什么要使用synchronized？

线程的同步是为了防止多个线程访问一个数据对象时，对数据形成的破坏。为确保共享变量不会出现并发问题，一般会对修改共享变量的代码块用synchronized加锁，确保同一时刻只有一个线程在修改共享变量，从而避免并发问题。因此须要紧紧记住“共享”这两个字，只有共享资源的读写访问才须要同步化，若是不是共享资源，那么就没有同步的必要。安全

2、synchronized修饰范围

  1. 修饰实例方法 > 多个线程访问同一个实例的加锁方法时，会出现锁的竞争多线程

  2. 修饰静态方法 > 多个线程访问类的加锁方法时，会出现锁的竞争并发

  3. 修饰代码块 > 多线程访问到同一个代码块时，会出现竞争的问题ide

3、synchronized同步锁对象

synchronized能够用来修饰方法或代码块，咱们能够把获取的同步锁归为如下3种：学习

  1. 实例对象锁：修饰在普通方法上(非静态方法)；在代码块中修饰this即synchronized(this)代码块
  2. 类对象锁：修饰在静态方法上；在代码块中修饰class即synchronized(X.class)代码块
  3. 同步块非当前实例对象锁：在代码块中修饰非当前实例对象，好比在X类中synchronized(对象a)的代码

对这3种不一样的锁，使用相互之间不受影响，对于同一种锁，会出现锁的竞态条件。测试

4、synchronized同步锁使用

对于1.实例对象锁的使用：this

  • 全部的非静态同步方法用的都是同一把锁—实例对象自己，也就是说若是一个实例对象的非静态同步方法获取锁后，该实例对象的其余非静态同步方法必须等待获取锁的方法释放锁后才能获取锁。
  • 实例对象锁存在于当前实例，不一样的实例对象的锁相互之间不受影响。
  • synchronized(this)代码块获取的是该实例对应的锁，与非静态的synchronized同步方法使用的是同一把锁，会出现锁的竞争。
  • 实例锁和类对象锁没有影响，不会形成彼此阻塞。

对于2.类对象锁的使用：spa

  • 对于静态同步方法，锁是针对这个类的，锁对象是该类的Class对象。
  • 而全部的静态同步方法用的也是同一把锁——类对象自己，若是一个静态同步方法获取锁后，其余的静态同步方法都必须等待该方法释放锁后才能获取锁。
  • 不论是同一个实例对象的静态同步方法之间，仍是不一样的实例对象的静态同步方法之间，他们都使用的是同一个类的对象锁，会出现锁的竞争。
  • synchronized(X.class)代码块使用的是类Class的对象锁，与类中静态同步方法会出现锁的竞争。多个类中的synchronized(X.class)代码块也会出现锁的竞态条件。

对于3.同步块非当前实例对象锁的使用：.net

  • 对于同步块，因为其对象锁是能够选择的，只有使用同一把锁的同步块之间才有着竞态条件。
  • 同步锁的对象是基于实际对象而不是对象引用的，因此使用时特别注意，在锁的做用域中因改变实际对象引用从而引发锁的对象改变致使同步锁失去竞太条件。

5、synchronized使用小结

关于锁和同步的使用，汇总如下几个要点：
一、同步锁只能经过同步方法去保证共享变量安全，而不是同步变量和类。
二、当提到同步时，应该清楚在什么上同步？也就是说，在哪一个对象上同步？
三、没必要同步类中全部的方法，类能够同时拥有同步和非同步方法。
四、对于出现竞态条件锁的线程，一个线程获取了锁，其余线程会阻塞等待该锁的释放去获取该锁。
五、若是线程拥有同步和非同步方法，则非同步方法能够被多个线程自由访问而不受锁的限制。
六、线程睡眠时，它所持的任何锁都不会释放。
七、线程能够得到多个重进入（synchronized ）锁。好比，在一个对象的同步方法里面调用另一个对象的同步方法，则获取了两个对象的同步锁。
八、同步损害并发性，应该尽量缩小同步范围。同步不但能够同步整个方法，还能够同步方法中一部分代码块。
九、在使用同步代码块时候，应该指定在哪一个对象上同步，也就是说要获取哪一个对象的锁
十、编写线程安全的类，须要时刻注意对多个线程竞争访问资源的逻辑和安全作出正确的判断，对“原子”操做作出分析，并保证原子操做期间别的线程没法访问。
 

3.测试case代码

package com.test.synchroniz;

public class Service {
    
    public Service(){
        System.out.println("当前线程：" + Thread.currentThread().getName() + " 构造方法");
    }
    
    static{
        System.out.println("当前线程：" + Thread.currentThread().getName() + " 静态代码块");
    }
    
    private Object object1 = new Object();
    private Object object2 = new Object();
    
    synchronized public static void printA(){
        try{
            System.out.println("当前线程：" + Thread.currentThread().getName() + Thread.currentThread().getId() +"在 " + System.currentTimeMillis() + " 进入方法A");
            Thread.sleep(3000);
            System.out.println("当前线程：" + Thread.currentThread().getName()  + Thread.currentThread().getId()  +"在 " + System.currentTimeMillis() + " 退出方法A");
        }catch(Exception e){
            System.out.println(e);
        }
    }
    
    synchronized public void printB(){
        try{
            System.out.println("当前线程：" + Thread.currentThread().getName() + Thread.currentThread().getId() +"在 " + System.currentTimeMillis() + " 进入方法B");
            Thread.sleep(3000);
            System.out.println("当前线程：" + Thread.currentThread().getName()  + Thread.currentThread().getId()  +"在 " + System.currentTimeMillis() + " 退出方法B");
        }catch(Exception e){
            System.out.println(e);
        }
    }
    
     public void printC(){
         System.out.println("当前线程：" + Thread.currentThread().getName() + Thread.currentThread().getId() +"在 " + System.currentTimeMillis() + " 进入方法C");
        try{
            synchronized(object1){
                System.out.println("当前线程：" + Thread.currentThread().getName() + Thread.currentThread().getId() +"在 " + System.currentTimeMillis() + "进入方法C--synchronized{X}");
                Thread.sleep(3000);
                System.out.println("当前线程：" + Thread.currentThread().getName() + Thread.currentThread().getId() +"在 " + System.currentTimeMillis() + " 退出方法C-synchronized{X}");
            }
            System.out.println("当前线程：" + Thread.currentThread().getName() + Thread.currentThread().getId() +"在 " + System.currentTimeMillis() + " 退出方法C");
            }catch(Exception e){
            System.out.println(e);
        }
    }

    
     public void printD(){
         System.out.println("当前线程：" + Thread.currentThread().getName() + Thread.currentThread().getId() +"在 " + System.currentTimeMillis() + " 进入方法D");
        try{
            synchronized(object2){
                System.out.println("当前线程：" + Thread.currentThread().getName() + Thread.currentThread().getId() +"在 " + System.currentTimeMillis() + "进入方法D--synchronized{X}");
                Thread.sleep(3000);
                System.out.println("当前线程：" + Thread.currentThread().getName() + Thread.currentThread().getId() +"在 " + System.currentTimeMillis() + " 退出方法D-synchronized{X}");
            }
            System.out.println("当前线程：" + Thread.currentThread().getName() + Thread.currentThread().getId() +"在 " + System.currentTimeMillis() + " 退出方法D");
            }catch(Exception e){
            System.out.println(e);
        }
    }
     
     public void printE(){
         System.out.println("当前线程：" + Thread.currentThread().getName() + Thread.currentThread().getId() +"在 " + System.currentTimeMillis() + " 进入方法E");
        try{
            synchronized(this){
                System.out.println("当前线程：" + Thread.currentThread().getName() + Thread.currentThread().getId() +"在 " + System.currentTimeMillis() + " 进入方法E--synchronized{this}");
                Thread.sleep(3000);
                System.out.println("当前线程：" + Thread.currentThread().getName() + Thread.currentThread().getId() +"在 " + System.currentTimeMillis() + " 退出方法E-synchronized{this}");
            }
            System.out.println("当前线程：" + Thread.currentThread().getName() + Thread.currentThread().getId() +"在 " + System.currentTimeMillis() + " 退出方法E");
            }catch(Exception e){
            System.out.println(e);
        }
    }
     
     public static void printF(){
         System.out.println("当前线程：" + Thread.currentThread().getName() + Thread.currentThread().getId() +"在 " + System.currentTimeMillis() + " 进入方法E");
        try{
            synchronized(Service.class){
                System.out.println("当前线程：" + Thread.currentThread().getName() + Thread.currentThread().getId() +"在 " + System.currentTimeMillis() + " 进入方法F--synchronized{class}");
                Thread.sleep(3000);
                System.out.println("当前线程：" + Thread.currentThread().getName() + Thread.currentThread().getId() +"在 " + System.currentTimeMillis() + " 退出方法F-synchronized{class}");
            }
            System.out.println("当前线程：" + Thread.currentThread().getName() + Thread.currentThread().getId() +"在 " + System.currentTimeMillis() + " 退出方法F");
            }catch(Exception e){
            System.out.println(e);
        }
    }
     
    public void printG(){
         System.out.println("当前线程：" + Thread.currentThread().getName() + Thread.currentThread().getId() +"在 " + System.currentTimeMillis() + " 进入方法G");
        try{
            synchronized(Service.class){
                System.out.println("当前线程：" + Thread.currentThread().getName() + Thread.currentThread().getId() +"在 " + System.currentTimeMillis() + " 进入方法G--synchronized{class}");
                Thread.sleep(3000);
                System.out.println("当前线程：" + Thread.currentThread().getName() + Thread.currentThread().getId() +"在 " + System.currentTimeMillis() + " 退出方法G-synchronized{class}");
            }
            System.out.println("当前线程：" + Thread.currentThread().getName() + Thread.currentThread().getId() +"在 " + System.currentTimeMillis() + " 退出方法G");
            }catch(Exception e){
            System.out.println(e);
        }
    }



}
View Code 
package com.test.synchroniz;

/**
 * 0.synchronized同步方法、synchronized静态同步方法分别是用到的是实例锁，类锁，一个线程获取到synchronized同步方法的锁时，
 * 另外一线程依然能够进入synchronized静态同步方法（实例锁，类锁二者不一样，相互不影响
 * ）
 * 1.synchronized同步方法，synchronized(this)都是对象锁，对于其余线程调用synchronized同步方法，synchronized(this)呈阻塞状态 </br>
 * 2.同一时间同一线程只有一个线程获取对象锁执行 </br>
 * 
 * 1.synchronized(非this)对象锁，对于非this若是是同一对象，两个线程同时只有一个能够获取该锁 </br>
 * 2.对象锁（synchronized同步方法 或 synchronized(this)）、synchronized(非this)对象锁 两个线程同时执行，均可得到各自的锁 </br>
 *
 * 1.synchronized修饰static方法与synchronized(X.class)做用同样
 * 
 * @author fugaoyang
 *
 */
public class TestRun {

    public static void main(String[] args) throws Exception {
        Service service = new Service();
        Thread threadA = new Thread("A"){
            @Override
            public void run(){
                service.printA();
            }
        };
        
        Thread threadB = new Thread("B"){
            @Override
            public void run(){
                service.printB();
            }
        };
        
        Thread threadC = new Thread("C"){
            @Override
            public void run(){
                service.printC();
            }
        };
        
        Thread threadD = new Thread("D"){
            @Override
            public void run(){
                service.printD();
            }
        };
        
        Thread threadE = new Thread("E"){
            @Override
            public void run(){
                service.printE();
            }
        };
        
        Thread threadF = new Thread("F"){
            @Override
            public void run(){
                service.printF();
            }
        };
        
        Thread threadG = new Thread("G"){
            @Override
            public void run(){
                service.printG();
            }
        };
        
        threadA.start();
        //threadB.start();
        //threadC.start();
        //threadD.start();
        //threadE.start();
        threadF.start();
        threadG.start();
        
        threadA.join();
        threadF.join();
        threadG.join();
    }
}
View Code
 
本篇文章主要总结了synchronized同步锁的使用，同步锁的原理和机制后续会作深刻了解和学习。
 
本文参考部分出处：
3.《Java多线程编程核心技术-高洪严》
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程