`
azrael6619
  • 浏览: 580867 次
  • 性别: Icon_minigender_1
  • 来自: 杭州
社区版块
存档分类
最新评论

synchronized的使用及说明

阅读更多

synchronized的作用 
一、同步方法
public synchronized void methodAAA(){

//….

}
锁定的是调用这个同步方法的对象

测试:
a、不使用这个关键字修饰方法,两个线程调用同一个对象的这个方法。
目标类:

public class TestThread {
    public  void execute(){  //synchronized,未修饰
         for(int i=0;i<100;i++){
            System.out.println(i);
        }    
    }
} 

 
线程类:

public class ThreadA implements Runnable{
    TestThread test=null;
    public ThreadA(TestThread pTest){  //对象有外部引入,这样保证是同一个对象
        test=pTest;
    }
    public void run() {
        test.execute();
    }
} 

 
调用:

TestThread test=new TestThread();
Runnable runabble=new ThreadA(test);
Thread a=new Thread(runabble,"A");                
a.start();
Thread b=new Thread(runabble,"B");
b.start(); 

 
结果:
输出的数字交错在一起。说明不是同步的,两个方法在不同的线程中是异步调用的。

b、修改目标类,增加synchronized修饰

public class TestThread {
    public synchronized  void execute(){  //synchronized修饰
        for(int i=0;i<100;i++){
            System.out.println(i);
        }    
    }
} 

 
结果:
输出的数字是有序的,首先输出A的数字,然后是B,说明是同步的,虽然是不同的线程,但两个方法是同步调用的。
注意:上面虽然是两个不同的线程,但是是同一个实例对象。下面使用不同的实例对象进行测试。

c、每个线程都有独立的TestThread对象。
目标类:


线程类:

public class TestThread {
    public synchronized void execute(){  //synchronized修饰
        for(int i=0;i<100;i++){
            System.out.println(i);
        }    
    }
}

 
调用:

TestThread test=new TestThread();   
Runnable runabble=new ThreadA(test);   
TestThread test2=new TestThread();   
Runnable runabble2=new ThreadA(test2);  
Thread a=new Thread(runabble,"A");                   
a.start();   
Thread b=new Thread(runabble2,"B");   
b.start();   

 
结果:
输出的数字交错在一起。说明虽然增加了synchronized 关键字来修饰方法,但是不同的线程调用各自的对象实例,两个方法仍然是异步的。

引申:
对于这种多个实例,要想实现同步即输出的数字是有序并且按线程先后顺序输出,我们可以增加一个静态变量,对它进行加锁(后面将说明锁定的对象)。

修改目标类:

public class TestThread {
    private static Object lock=new Object(); //必须是静态的。
    public  void execute(){
        synchronized(lock){
            for(int i=0;i<100;i++){
                System.out.println(i);
            }    
        }
    }
} 

 

二、同步代码块

public void method(SomeObject so){
    synchronized(so)
       //…..
    }
} 

 

锁定一个对象,其实锁定的是该对象的引用(object reference)
谁拿到这个锁谁就可以运行它所控制的那段代码。当有一个明确的对象作为锁时,就可以按上面的代码写程序,但当没有明确的对象作为锁,只是想让一段代码同步时,可以创建一个特殊的instance变量(它必须是一个对象)来充当锁(上面的解决方法就是增加了一个状态锁)。

a、锁定一个对象,它不是静态的
private byte[] lock = new byte[0]; // 特殊的instance变量
目标类:

public class TestThread {
    private Object lock=new Object(); 
    public  void execute(){
        synchronized(lock){  //增加了个锁,锁定了对象lock,在同一个类实例中,是线程安全的,但不同的实例还是不安全的。因为不同的实例有不同对象锁lock
            for(int i=0;i<100;i++){
                System.out.println(i);
            }    
        }
    }
}   

 
其实上面锁定一个方法,等同于下面的:

public void execute(){  
    synchronized(this){   //同步的是当前对象
        for(int i=0;i<100;i++){
            System.out.println(i);
        }    
    }
} 

 

b、锁定一个对象或方法,它是静态的
这样锁定,它锁定的是对象所属的类
public synchronized  static void execute(){
    //...
}
等同于

public class TestThread {
    public static void execute(){
        synchronized(TestThread.class){
            //
        }
    }
} 

 

测试:

目标类:

public class TestThread {
    private static Object lock=new Object();
    public synchronized static void execute(){  //同步静态方法
        for(int i=0;i<100;i++){
            System.out.println(i);
        }    
    }
    public static void execute1(){
        for(int i=0;i<100;i++){
            System.out.println(i);
        }    
    }
    public void test(){
        execute();     //输出是有序的,说明是同步的
        //execute1();  //输出是无须的,说明是异步的
    }
} 

 

线程类:调用不同的方法,于是建立了两个线程类

public class ThreadA implements Runnable{
    public void run() {
        TestThread.execute();//调用同步静态方法
    }
}
public class ThreadB implements Runnable{
    public void run() {
        TestThread test=new TestThread();
        test.test();//调用非同步非静态方法
    }
} 

 

调用:

Runnable runabbleA=new ThreadA();
Thread a=new Thread(runabbleA,"A");                
a.start();
Runnable runabbleB=new ThreadB();
Thread b=new Thread(runabbleB,"B");                
b.start();  

 

注意:
1、用synchronized 来锁定一个对象的时候,如果这个对象在锁定代码段中被修改了,则这个锁也就消失了。看下面的实例:

目标类:

public class TestThread {
    private static final class TestThreadHolder {
           private static TestThread theSingleton = new TestThread();
           public static TestThread getSingleton() {
               return theSingleton;
           }
           private TestThreadHolder() {
           }
         }
     
    private Vector ve =null;
    private Object lock=new Object();
    private TestThread(){
          ve=new Vector();
          initialize();
      }
    public static TestThread getInstance(){
        return TestThreadHolder.getSingleton();
      }
    private void initialize(){
        for(int i=0;i<100;i++){
              ve.add(String.valueOf(i));
          }
      }
    public void reload(){
        synchronized(lock){
              ve=null;            
              ve=new Vector();
                        //lock="abc"; 
            for(int i=0;i<100;i++){
                  ve.add(String.valueOf(i));
              }
          }
          System.out.println("reload end");
      }
    
    public boolean checkValid(String str){
        synchronized(lock){
              System.out.println(ve.size());
            return ve.contains(str);
          }
      }
}

说明:在reload和checkValid方法中都增加了synchronized关键字,对lock对象进行加锁。在不同线程中对同一个对象实例分别调用reload和checkValid方法。
在reload方法中,不修改lock对象即注释lock="abc"; ,结果在控制台输出reload end后才输出100。说明是同步调用的。
如果在reload方法中修改lock对象即去掉注释,结果首先输出了一个数字(当前ve的大小),然后输出reload end。说明是异步调用的。

2、单例模式中对多线程的考虑

public class TestThread {
     private static final class TestThreadHolder {
            private static TestThread theSingleton = new TestThread();
            public static TestThread getSingleton() {
                return theSingleton;
            }
            private TestThreadHolder() {
            }
        }
     private Vector ve =null;
     private Object lock=new Object();
     private TestThread(){
         ve=new Vector();
         initialize();
     }
     public static TestThread getInstance(){
         return TestThreadHolder.getSingleton();
     }
}

 

说明:增加了一个内部类,在内部类中申明一个静态的对象,实例化该单例类,初始化的数据都在单例类的构造函数中进行。这样保证了多个实例同时访问的时候,初始化的数据都已经成功初始化了。

分享到:
评论

相关推荐

    Synchronized 终极说明教程

    《Synchronized 终极说明教程》 在Java编程语言中,多线程是并发执行任务的重要方式,而`synchronized`关键字则是确保线程安全、防止数据竞争的关键工具。本教程将深入探讨`synchronized`的各个方面,包括其用法、...

    Java多线程中使用synchronized说明

    使用`synchronized`时,需要警惕死锁和活锁的情况。死锁是指两个或多个线程相互等待对方释放资源,导致它们都无法继续执行。活锁则是线程虽然没有阻塞,但由于某种原因不断重试导致无法继续执行。 7. **可重入性**...

    java的lock和synchronized的区别.docx

    Java 中的 Lock 和 Synchronized 的区别 Java 语言中有很多相似关键字或相似意义的字,但 lock 和 synchronized 是两个最容易混淆的关键字。它们都是锁的意思,都是为了线程安全性、应用合理性和运行效率的。下面...

    java 偏向锁、轻量级锁及重量级锁synchronized原理.docx

    轻量级锁使用CAS(Compare and Swap,比较并交换)操作来尝试获取锁,如果成功,就继续执行;如果失败,说明已有其他线程持有锁,这时轻量级锁升级为重量级锁。 3. **重量级锁**:重量级锁是通过操作系统互斥量进行...

    Java并发控制机制ReentrantLock详解与synchronized对比分析

    使用场景及目标:适用于需要深入了解Java并发控制机制,特别是希望在实际项目中选择合适的同步工具的人群。通过对ReentrantLock和synchronized的全面比较,帮助开发者更好地理解和应用这两种锁定机制。 其他说明:...

    Java中的关键字synchronized 详解

    3. 如果不是,则尝试使用CAS算法将线程ID更新至对象头中。 4. 成功,获得锁,执行同步代码。更新失败表明存在锁竞争,等待全局安全点,暂停拥有偏向锁的线程,根据对象头的锁标志位,选择将偏向锁升级为轻量锁或者置...

    Java 并发编程学习笔记之Synchronized简介

    Java并发编程中的Synchronized关键字是Java提供的一种内置锁机制,...然而,过度使用Synchronized可能会导致性能下降,因此在实际开发中需要权衡其使用,适时选择更适合的并发控制策略,如ReentrantLock、Semaphore等。

    Java 并发编程学习笔记之Synchronized底层优化

    3. 失败则说明有竞争,可能需要唤醒被挂起的线程。 **三、偏向锁** 偏向锁的设计是为了在只有一个线程访问同步块时避免不必要的锁操作。在无锁竞争时,线程第一次获取锁时,Mark Word会记录线程ID,后续该线程再次...

    第16讲synchronized底层如何实现?什么是锁...1

    1. **偏斜锁(Biased Locking)**:在没有竞争的情况下,synchronized会尝试使用偏斜锁,这是一种优化策略。JVM会在对象头的Mark Word中存储当前线程ID,表示对象偏向于该线程。如果只有一个线程访问,避免了锁的...

    线程说明内附源码

    根据提供的文档标题、描述、标签及部分内容,我们可以总结并扩展出以下有关Java线程机制的知识点: ### Java线程机制概述 #### 1. **线程的基本概念** - 在Java中,线程是程序执行流的最小单位,一个标准的Java...

    linux(Red_Hat)NTP时间同步的配置方法

    本文将详细介绍 Linux(Red Hat)NTP 时间同步的配置方法,包括 NTP 跟踪层级安排、NTP 配置数据对单点故障应对能力的评估、NTP 服务器(redhat 服务器)的配置数据及说明、NTP 客户机(redhat 服务器)的配置数据及说明...

    制作工具类及说明文档

    6. **文档注释**:为了帮助其他开发者理解工具类的方法,应该为每个方法编写详细的Javadoc注释,包括参数说明、返回值、可能抛出的异常以及使用示例。 7. **异常处理**:工具类中的方法应合理处理异常,提供友好的...

    MMS——SMIL的使用说明

    ### MMS——SMIL的使用说明与特性详解 #### 一、引言 随着多媒体技术的飞速发展,用户对于高质量、个性化多媒体内容的需求日益增长。SMIL(Synchronized Multimedia Integration Language,同步多媒体集成语言)...

    java语言说明书

    13. **并发编程**:Java提供了强大的并发工具和API,如ExecutorService、Future、Semaphore等,以及synchronized关键字和volatile变量,支持多线程编程。 14. **Java EE(企业版)**:Java EE是用于构建企业级应用...

    一个简单的java类,说明了锁的粒度

    可能包含了使用`synchronized`修饰实例方法和静态方法的例子,以对比它们在多线程环境下的行为差异。 了解了这些基础知识后,我们可以进一步探讨锁的粒度选择对性能的影响。粒度较粗的锁(如类级别锁)可能导致更多...

    JavaScript关键字保留字属性及说明

    - `synchronized`:保留用于同步操作。 - `throws`:保留用于抛出异常。 - `transient`:保留用于暂时存储。 - `volatile`:保留用于多线程环境中变量的状态更新。 #### 二、转义字符 JavaScript中使用转义...

    Java项目实战-基于java博网即时通讯软件的设计与实现(附源码,部署说明).zip

    3. **多线程**:为了实现即时通讯的实时性,项目中必定大量使用了多线程技术,比如创建线程池、使用ExecutorService,以及线程间的同步与互斥控制,可能运用了wait、notify、join等方法,或者锁(synchronized关键字...

    并发面试专题.docx

    1. 如果 Synchronized 明确指定了锁对象,比如 Synchronized(变量名) 、Synchronized( this) 等,说明加解锁对象为该对象。 2. 如果没有明确指定:若 Synchronized 修饰的方法为非静态方法,表示此方法对应的...

    Java线程核心技术及常见面试问题解答

    内容概要:本文详细介绍了Java线程的基本概念、线程的安全与同步机制、多种线程间通信方式、Java内存模型,以及线程池的原理与使用技巧,涵盖了许多常用的线程和并发控制组件如synchronized、ReentrantLock、...

    rabbitmq、spring、synchronized、redis面试题

    以下是对这些主题的详细说明: 首先,RabbitMQ是一个广泛使用的开源消息队列系统,基于AMQP(Advanced Message Queuing Protocol)协议。它允许分布式应用之间异步通信,通过缓存消息来处理高并发场景,避免了服务...

Global site tag (gtag.js) - Google Analytics