精华内容
下载资源
问答
  • 主要介绍了Java 同步锁(synchronized)详解及实例的相关资料,需要的朋友可以参考下
  • java同步与互斥资料收集 java同步与互斥资料收集 java同步与互斥资料收集java同步与互斥资料收集
  • java同步synchronized关键字用法示例
  • java同步mysql数据

    千次阅读 2016-12-23 17:50:12
    java同步mysql数据同步表数据和修改java程序的过程,将这些记录下来: 业务说明 解决方案 表信息 同步程序 遇到的问题 业务说明 由于业务变更,系统内涉及到使用aid的程序都要求替换为bid,一共涉及多张表的数据...

    java同步mysql数据

    同步表数据和修改java程序的过程,将这些记录下来:

    • 业务说明
    • 解决方案
    • 表信息
    • 同步程序
    • 遇到的问题

    业务说明

    由于业务变更,系统内涉及到使用aid的程序都要求替换为bid,一共涉及多张表的数据需要清洗,下面以其中一张表rule来讲述。

    解决方案

    1.创建相同表结构rules
    2.同步表rule到表rules
    3.将应用程序中使用表rule替换为表rules

    表信息

    rule 表结构如下:

    字段说明
    id主键,自动增长列
    rule_id规则编号
    create_id创建人Id
    create_time创建时间
    update_id更新人Id
    update_time更新时间

    rule_id字段存的值需要替换,有aid替换为bid,具体数据如下:

    aidbid
    201409C2000000003KS1201506CG230000049
    201311CM010000171KS1201506CG230000050

    创建表rules
    为了不影响线上环境,创建了表rules,结构同表rule,好处在于清理数据时不影响线上正常业务数据。

    rules 表结构如下:

    字段说明
    id主键,自动增长列
    rule_id规则编号
    create_id创建人Id
    create_time创建时间
    update_id更新人Id
    update_time更新时间

    同步程序

    业务逻辑如下:
    * 1.同步数据,一次读取表rule的1000条记录,且替换aid为bid,写入表rules
    * 2.判断新增or更新
    * 3.如果rule.id在rules表不存在,则insert
    * 4.如果rule.id在rules表存在,且rules.update_time<>rules.update_time,则update

    程序如下:

    public void synchronizeCouponRulesDddc(){
            logger.info("synchronizeCouponRulesDddc---开始");
            Map<String, Object> param = new HashMap<String, Object>();
            Map<String, Object> param2 = new HashMap<String, Object>();
            int total = couponOldForNewMapper.synchronizeCouponRulesCount();
            if (total > 0) {
                int startIndex = 0, batchSize = 1000;
                while (startIndex < total) {
                    param.put("startIndex", startIndex);
                    param.put("batchSize", batchSize);
                    List<com.feiniu.coupon.entity.newCoupon.CouponRule> couponRulesList = couponOldForNewMapper.synchronizeCouponRules(param);
                    Set<Integer> idsSet = new HashSet<Integer>();
                    //插入数据导关联表
                    if (CollectionUtils.isNotEmpty(couponRulesList)) {
                        for (com.feiniu.coupon.entity.newCoupon.CouponRule couponRules : couponRulesList) {
                            String type = couponRules.getType();
                            if ("3".equals(type) || "4".equals(type) || "12".equals(type) || "13".equals(type)) {
                                String typeSeq = couponRules.getTypeSeq();
                                couponRules.setTypeSeq(this.replaceSmId(typeSeq));
                            }
                            idsSet.add(couponRules.getId());
                        }
                    }
                    String idsStr ="'"+ StringUtils.join(idsSet, "','") +"'";
                    param2.put("ids", idsStr);
                    List<com.feiniu.coupon.entity.newCoupon.CouponRule> couponRulesDddcList = couponOldForNewMapper.synchronizeCouponRulesDddc(param2);
    
                    List<com.feiniu.coupon.entity.newCoupon.CouponRule> updateList = new ArrayList<com.feiniu.coupon.entity.newCoupon.CouponRule>();
                    if (CollectionUtils.isNotEmpty(couponRulesDddcList)) {
                        for (com.feiniu.coupon.entity.newCoupon.CouponRule couponRules : couponRulesList) {
                            for (com.feiniu.coupon.entity.newCoupon.CouponRule couponRulesDddc : couponRulesDddcList) {
                                if (couponRules.getId().equals(couponRulesDddc.getId())
                                        && couponRules.getUpdateTime().getTime() != couponRulesDddc.getUpdateTime().getTime()) {
                                        updateList.add(couponRules);
                                }
                            }
                        }
                    }
    
                    List<com.feiniu.coupon.entity.newCoupon.CouponRule> insertList = new ArrayList<com.feiniu.coupon.entity.newCoupon.CouponRule>();;
                    if (CollectionUtils.isNotEmpty(couponRulesDddcList)) {
                        Set<Integer> dddcSet = new HashSet<Integer>();
                        for (com.feiniu.coupon.entity.newCoupon.CouponRule couponRulesDddc : couponRulesDddcList) {
                            dddcSet.add(couponRulesDddc.getId());
                        }
                        for (com.feiniu.coupon.entity.newCoupon.CouponRule couponRules : couponRulesList) {
                            if (!dddcSet.contains(couponRules.getId())) {
                                insertList.add(couponRules);
                            }
                        }
                    } else {
                        insertList = couponRulesList;
                    }
    
                    if (CollectionUtils.isNotEmpty(insertList)) {
                        for (com.feiniu.coupon.entity.newCoupon.CouponRule insertCouponRules : insertList) {
                            couponOldForNewMapper.insertCouponRulesDddc(insertCouponRules);
                        }
                    } 
                    if (CollectionUtils.isNotEmpty(updateList)) {
                        for (com.feiniu.coupon.entity.newCoupon.CouponRule updateCouponRules : updateList) {
                            couponOldForNewMapper.updateCouponRulesDddc(updateCouponRules);
                        }
                    }
                    startIndex += batchSize;
                    logger.info("synchronizeCouponData.synchronizeCouponRulesDddc---"+startIndex);
                }
            }
        }

    遇到的问题

    1.原因是数据库里面有char类型的字段其内容为空格

    Caused by: java.lang.StringIndexOutOfBoundsException: String index out of range: 0
        at java.lang.String.charAt(String.java:658)
        at org.apache.ibatis.type.CharacterTypeHandler.getNullableResult(CharacterTypeHandler.java:37)
        at org.apache.ibatis.type.CharacterTypeHandler.getNullableResult(CharacterTypeHandler.java:26)
        at org.apache.ibatis.type.BaseTypeHandler.getResult(BaseTypeHandler.java:55)
        at org.apache.ibatis.executor.resultset.DefaultResultSetHandler.getPropertyMappingValue(DefaultResultSetHandler.java:393)
        at org.apache.ibatis.executor.resultset.DefaultResultSetHandler.applyPropertyMappings(DefaultResultSetHandler.java:367)
        at org.apache.ibatis.executor.resultset.DefaultResultSetHandler.getRowValue(DefaultResultSetHandler.java:341)
        at org.apache.ibatis.executor.resultset.DefaultResultSetHandler.handleRowValuesForSimpleResultMap(DefaultResultSetHandler.java:294)
        at org.apache.ibatis.executor.resultset.DefaultResultSetHandler.handleRowValues(DefaultResultSetHandler.java:269)
        at org.apache.ibatis.executor.resultset.DefaultResultSetHandler.handleResultSet(DefaultResultSetHandler.java:239)
        at org.apache.ibatis.executor.resultset.DefaultResultSetHandler.handleResultSets(DefaultResultSetHandler.java:153)
        at org.apache.ibatis.executor.statement.PreparedStatementHandler.query(PreparedStatementHandler.java:60)
        at org.apache.ibatis.executor.statement.RoutingStatementHandler.query(RoutingStatementHandler.java:73)

    2.mybaitis批量insert使用$ 符号

    字段存放的值包含单引号和’$’前后的单引号冲突导致程序报错,使用#可以避免问题。

    <insert id="insertBatchCouponRulesDddc"  useGeneratedKeys="true"  parameterType="java.util.List">
            insert into coupon.coupon_rules_dddc(id,
                                                 coupon_id,
                                                 type,
                                                 type_seq,
                                                 type_seq_name,
                                                 is_use,
                                                 create_id,
                                                 create_time,
                                                 update_id,
                                                 update_time)
            values
            <foreach collection="list" item="item" index="index"  separator="," >
                 '${item.id}',
                 '${item.couponId}', 
                 '${item.type}', 
                 '${item.typeSeq}', 
                 '${item.typeSeqName}',
                 '${item.isUse}', 
                 '${item.createId}',
                 '${item.createTime}',
                 '${item.updateId}',
                 '${item.updateTime}')
            </foreach>
        </insert>

    3.重点关注rules.id自动增长列,存在情况如下:
    1)线上rule.id从1增长到了1000000;
    2)这时候同步数据rule到rules,rules.id数据为1到1000000,创建自动增长列从1000000开始;
    3)部署应用java程序,在此期间rule新增20000数据,rule.id增长到1020000;
    4)部署应用程序后读写rules表,此时要自动同步rule新增的20000记录,这样会造成rules.id冲突,造成同步rule的数据会和新增rules表数据争用。
    5)这里我们为了保险起见,在设置rules.id从1500000开始增长,这样即使rule有数据增加,也不会影响rules表读写数据。

    展开全文
  • 主要介绍了JAVA同步、异步、阻塞和非阻塞之间的区别,文中讲解非常细致,帮助大家更好的理解和学习,感兴趣的朋友可以了解下
  • java 同步块(Java Synchronized Blocks)

    万次阅读 2013-06-27 15:26:25
    java 同步块(Java Synchronized Blocks) Java 同步块包括方法同步和代码块同步java 同步可以避免资源竞争,避免死锁。 主题包括的主要内容: synchronized 关键字Synchronized 实例方法Synchronized static...

    java 同步块(Java Synchronized Blocks)

    Java 同步块包括方法同步和代码块同步。java 同步可以避免资源竞争,避免死锁。

    主题包括的主要内容:

    The Java synchronized Keyword

    在java中,同步是用 synchronized 关键字代表的. 同步是针对对象和类来说的。一个对象上的所有同步块只能被一个线程锁住。其他所有的线程试图访问同步块的方法,都要等到占用资源的线程释放了才能访问。

    synchronized关键字可以用到4个种场景:

    1. Instance methods
    2. Static methods
    3. Code blocks inside instance methods
    4. Code blocks inside static methods

    Synchronized Instance Methods

    Here is a synchronized instance method:

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

    当一个方法上用到synchronized关键字,Java才能知道它是个同步方法。

    一个实例同步方法只属于实例本身。每个实例都有自己的同步方法。

    Synchronized Static Methods

    Static methods are marked as synchronized just like instance methods using thesynchronized keyword. Here is a Java synchronized static method example:

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

    同样 synchronized 告诉Java 这是一个同步方法。

    同步静态方法属于类对象。在VM中只有一个类对象,因此只能有一个线程执行静态同步方法。

    Synchronized Blocks in Instance Methods

    有时候, 不需要同步整个方法,只需要同步方法里面的一部分,可以借助同步块来完成工作。

    Here is a synchronized block of Java code inside an unsynchronized Java method:

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

    这个例子是用同步块标记一块同步代码。这个同步块代码就相当于同步方法。

    Notice how the Java synchronized block construct takes an object in parentheses. In the example "this" is used, which is the instance the add method is called on. The object taken in the parentheses by the synchronized construct is called a monitor object. The code is said to be synchronized on the monitor object. A synchronized instance method uses the object it belongs to as monitor object.

    对于同一个对象只能有一个线程访问同步块。

    下面两个方法的代码,效果是一样的。

     
      public class MyClass {
      
        public synchronized void log1(String msg1, String msg2){
           log.writeln(msg1);
           log.writeln(msg2);
        }
    
      
        public void log2(String msg1, String msg2){
           synchronized(this){
              log.writeln(msg1);
              log.writeln(msg2);
           }
        }
      }
    

    只能有一个线程执行(针对同一个对象) ;

    第二个方法是不同的线程执行的时候会在同步块里面发生等待(针对同一对象)。

    Synchronized Blocks in Static Methods

    下面两个静态方法是在类对象上的:

      public class MyClass {
    
        public static synchronized void log1(String msg1, String msg2){
           log.writeln(msg1);
           log.writeln(msg2);
        }
    
      
        public static void log2(String msg1, String msg2){
           synchronized(MyClass.class){
              log.writeln(msg1);
              log.writeln(msg2);  
           }
        }
      }
    

    一个线程只能在同一时间执行上面的任何一个方法。

    对于第二个方法:只能有一个线程在代码块里面执行。

    Java Synchronized Example


      public class MyClass {
    
    
        public static synchronized void log1(String msg1, String msg2){
    	 try {
    	    	    TimeUnit.SECONDS.sleep(5) ;
    	    	} catch (InterruptedException e) {
    	    	    e.printStackTrace();
    	    	}
           System.out.println(msg1);
           System.out.println(msg2);
        }
        
        public static synchronized void log3(String msg1, String msg2){
    	    System.out.println(msg1);
    	    System.out.println(msg2);  
        }
      
        public static void log2(String msg1, String msg2){
           synchronized(MyClass.class){
    	   try {
    	    	    TimeUnit.SECONDS.sleep(3) ;
    	    	} catch (InterruptedException e) {
    	    	    e.printStackTrace();
    	    	}
    	   System.out.println(msg1);
    	   System.out.println(msg2);  
           }
        }
        
        public static void log4(String msg1, String msg2){
    	synchronized(MyClass.class){
    	    
    	    System.out.println(msg1);
    	    System.out.println(msg2);  
    	}
        }
        
       
        public void log5(String msg1, String msg2){
    	synchronized(this){
    	    System.out.println(msg1);
    	    System.out.println(msg2);  
    	}
        }
        
      }
      public class SynchronizedTest {
    
    
        Thread t1 = new Thread(new Runnable() {
            
            @Override
            public void run() {
              
                MyClass.log1("msg11", "msg12") ;
            }
        }) ;
        Thread t2 = new Thread(new Runnable() {
            
            @Override
            public void run() {
               
                MyClass.log2("msg21", "msg22") ;
            }
        }) ;
        Thread t3 = new Thread(new Runnable() {
    	
    	@Override
    	public void run() {
    	    
    	    MyClass.log3("msg31", "msg32") ;
    	}
        }) ;
        
        Thread t4 = new Thread(new Runnable() {
    	
    	@Override
    	public void run() {
    	    
    	    MyClass.log4("msg41", "msg42") ;
    	}
        }) ;
        
        Thread t5 = new Thread(new Runnable() {
    	
    	@Override
    	public void run() {
    	    
    	   new  MyClass().log5("msg51", "msg52") ;
    	}
        }) ;
        
        public static void main(String[] args) {
    	SynchronizedTest st = new SynchronizedTest() ;
    	
    	st.t1.start() ;
    //	st.t3.start() ;
    	
    //	st.t2.start() ;
    //	st.t4.start() ;
    	st.t5.start() ;
    	
    	
    	 int i = 0 ;
    		while(true){
    		    try {
    			TimeUnit.SECONDS.sleep(1) ;
    			System.out.println("---------------> " + i);
    			i ++ ;
    			
    		    } catch (InterruptedException e) {
    			e.printStackTrace();
    		    }
    		    if(i > 10 ){
    			    break ;
    		    }
    		}
    		
    	
    	
        }
        
    }
    

    测试组合:

    1. 测试实例方法组合;

    2. 测试静态方法组合;

    3. 测试实例方法和静态方法组合;(注意方法里面的 sleep, 是为了做到更好的测试效果)。

    展开全文
  • 8 Java同步

    千次阅读 2013-09-18 11:07:15
    Java 同步块(synchronized block)用来标记方法或者代码块是同步的。...Java同步关键字(synchronzied)实例方法同步静态方法同步实例方法中同步块静态方法中同步块Java同步示例 Java 同步关键字(synch

    原文:http://ifeve.com/synchronized-blocks/

    Java 同步块(synchronized block)用来标记方法或者代码块是同步的。Java同步块用来避免竞争。本文介绍以下内容:

    • Java同步关键字(synchronzied)
    • 实例方法同步
    • 静态方法同步
    • 实例方法中同步块
    • 静态方法中同步块
    • Java同步示例

    Java 同步关键字(synchronized)

    Java中的同步块用synchronized标记。同步块在Java中是同步在某个对象上。所有同步在一个对象上的同步块在同时只能被一个线程进入并执行操作。所有其他等待进入该同步块的线程将被阻塞,直到执行该同步块中的线程退出。

    有四种不同的同步块:

    1. 实例方法
    2. 静态方法
    3. 实例方法中的同步块
    4. 静态方法中的同步块

    上述同步块都同步在不同对象上。实际需要那种同步块视具体情况而定。

    实例方法同步

    下面是一个同步的实例方法:

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

    注意在方法声明中同步(synchronized )关键字。这告诉Java该方法是同步的。

    Java实例方法同步是同步在拥有该方法的对象上。这样,每个实例其方法同步都同步在不同的对象上,即该方法所属的实例。只有一个线程能够在实例方法同步块中运行。如果有多个实例存在,那么一个线程一次可以在一个实例同步块中执行操作。一个实例一个线程。

    静态方法同步

    静态方法同步和实例方法同步方法一样,也使用synchronized 关键字。Java静态方法同步如下示例:

    1 public static synchronized void add(int value){
    2  count += value;
    3  }

    同样,这里synchronized 关键字告诉Java这个方法是同步的。

    静态方法的同步是指同步在该方法所在的类对象上。因为在Java虚拟机中一个类只能对应一个类对象,所以同时只允许一个线程执行同一个类中的静态同步方法。

    对于不同类中的静态同步方法,一个线程可以执行每个类中的静态同步方法而无需等待。不管类中的那个静态同步方法被调用,一个类只能由一个线程同时执行。

    实例方法中的同步块

    有时你不需要同步整个方法,而是同步方法中的一部分。Java可以对方法的一部分进行同步。

    在非同步的Java方法中的同步块的例子如下所示:

    1 public void add(int value){
    2  
    3     synchronized(this){
    4        this.count += value;
    5     }
    6   }

    示例使用Java同步块构造器来标记一块代码是同步的。该代码在执行时和同步方法一样。

    注意Java同步块构造器用括号将对象括起来。在上例中,使用了“this”,即为调用add方法的实例本身。在同步构造器中用括号括起来的对象叫做监视器对象。上述代码使用监视器对象同步,同步实例方法使用调用方法本身的实例作为监视器对象。

    一次只有一个线程能够在同步于同一个监视器对象的Java方法内执行。

    下面两个例子都同步他们所调用的实例对象上,因此他们在同步的执行效果上是等效的。

    01 public class MyClass {
    02  
    03    public synchronized void log1(String msg1, String msg2){
    04       log.writeln(msg1);
    05       log.writeln(msg2);
    06    }
    07  
    08    public void log2(String msg1, String msg2){
    09       synchronized(this){
    10          log.writeln(msg1);
    11          log.writeln(msg2);
    12       }
    13    }
    14  }

    在上例中,每次只有一个线程能够在两个同步块中任意一个方法内执行。

    如果第二个同步块不是同步在this实例对象上,那么两个方法可以被线程同时执行。

    静态方法中的同步块

    和上面类似,下面是两个静态方法同步的例子。这些方法同步在该方法所属的类对象上。

    01 public class MyClass {
    02     public static synchronized void log1(String msg1, String msg2){
    03        log.writeln(msg1);
    04        log.writeln(msg2);
    05     }
    06  
    07     public static void log2(String msg1, String msg2){
    08        synchronized(MyClass.class){
    09           log.writeln(msg1);
    10           log.writeln(msg2);
    11        }
    12     }
    13   }

    这两个方法不允许同时被线程访问。

    如果第二个同步块不是同步在MyClass.class这个对象上。那么这两个方法可以同时被线程访问。

    Java同步实例

    在下面例子中,启动了两个线程,都调用Counter类同一个实例的add方法。因为同步在该方法所属的实例上,所以同时只能有一个线程访问该方法。

    01 public class Counter{
    02      long count = 0;
    03  
    04      public synchronized void add(long value){
    05        this.count += value;
    06      }
    07   }
    08   public class CounterThread extends Thread{
    09  
    10      protected Counter counter = null;
    11  
    12      public CounterThread(Counter counter){
    13         this.counter = counter;
    14      }
    15  
    16      public void run() {
    17     for(int i=0; i<10; i++){
    18            counter.add(i);
    19         }
    20      }
    21   }
    22   public class Example {
    23  
    24     public static void main(String[] args){
    25       Counter counter = new Counter();
    26       Thread  threadA = new CounterThread(counter);
    27       Thread  threadB = new CounterThread(counter);
    28  
    29       threadA.start();
    30       threadB.start();
    31     }
    32   }

    创建了两个线程。他们的构造器引用同一个Counter实例。Counter.add方法是同步在实例上,是因为add方法是实例方法并且被标记上synchronized关键字。因此每次只允许一个线程调用该方法。另外一个线程必须要等到第一个线程退出add()方法时,才能继续执行方法。

    如果两个线程引用了两个不同的Counter实例,那么他们可以同时调用add()方法。这些方法调用了不同的对象,因此这些方法也就同步在不同的对象上。这些方法调用将不会被阻塞。如下面这个例子所示:

    01 public class Example {
    02  
    03    public static void main(String[] args){
    04      Counter counterA = new Counter();
    05      Counter counterB = new Counter();
    06      Thread  threadA = new CounterThread(counterA);
    07      Thread  threadB = new CounterThread(counterB);
    08  
    09      threadA.start();
    10      threadB.start();
    11    }
    12  }

    注意这两个线程,threadA和threadB,不再引用同一个counter实例。CounterA和counterB的add方法同步在他们所属的对象上。调用counterA的add方法将不会阻塞调用counterB的add方法。


    展开全文
  • Java 同步块(synchronized block)用来标记方法或者代码块是同步,避免线程的资源竞争和数据的不一致问题。  Java中的同步块用synchronized标记。同步块在Java中是同步在某个对象上。所有同步在这个对象上的同步...

               Java 同步块(synchronized block)用来标记方法或者代码块是同步,避免线程的资源竞争和数据的不一致问题。


     Java中的同步块用synchronized标记。同步块在Java中是同步在某个对象上。所有同步在这个对象上的同步块在同一时刻只能被一个线程进入并执行操作。

    其它对该对象的同步块的线程将被阻塞,直到执行该同步块中的线程执行完成退出。


    接下来介绍同步块的四种方式:


    实例方法同步


    下面是一个同步的实例方法:

    		public synchronized void add(int number){
    			sum=sum+number;
    		}


    在上面的add方法上声明同步(synchronized )关键字,这告诉Java该方法是同步的。这种声明方式是同步在拥有该方法的对象上。这种方式也是在实际的编程中使用的比较多的一种方式

    这种方式每个实例其方法同步都同步在不同的对象上,就是该方法所属的实例。通俗点讲就是多个线程对同一个实例的同步块进行调用时,同一时刻只有一个线程在调用。如果有多个实例

    多个线程分别对不用的实例同步块进行调用是互不影响的,不会造成等待。

    静态方法同步

    下面是一个静态方法同步:

    <span style="white-space:pre">	</span>public static synchronized void add(int number){
    			sum=sum+number;
    		}

    静态方法的同步是指同步在该方法所在的类对象上。因为在Java虚拟机中一个类只能对应一个类对象,所以同时只允许一个线程执行同一个类中的静态同步方法。


    对于不同类中的静态同步方法,一个线程可以执行每个类中的静态同步方法而无需等待。通俗的说,就是多个线程对类的静态同步方法,同一时刻只允许一个线程对该类的静态


    同步方法进行调用。


    实例方法中的同步块


    有时你不需要同步整个方法,而是同步方法中的一部分。Java可以对方法的一部分进行同步。


    在非同步的Java方法中的同步块的例子如下所示:

    public void add(int number){
    
    
    		synchronized(this){
    
    
    					sum=sum+number;
    
    
    			}
    		}


    该代码在执行时和实例同步方法一样。但是Java同步块需用括号将对象括起来。在上面代码中使用了“this”,即为调用add方法的实例本身。在同步构造器中用括号括起来的对象叫做监视器对象,这个监视器对象可以是this,也可以其它的对象不如string对象等等。上述代码使用监视器对象同步,同步实例方法使用调用方法本身的实例作为监视器对象。


    一次只有一个线程能够在同步于同一个监视器对象的Java方法内执行。


    静态方法中的同步块


    静态方法中的同步块和上面类似,下面是两个静态方法同步的例子。这些方法同步在该方法所属的类对象上。

    public class SynStaticTest {
    	private static long sum=0;
        public static synchronized void add(long num){
           sum=sum+num;
       }
    
    
        public static  void deleye(long num){
    
    
          synchronized(SynStaticTest.class){
    			sum=sum-num;
          }
        }
     }


    以上类中的两个方法是不允许同时被线程访问的,也就是说同一时刻只允许调用执行一个方法。
    展开全文
  • 管程 — Java同步的基本思想

    千次阅读 多人点赞 2018-05-17 11:17:28
    它也可用于Java同步中。这篇文章使用了一个比喻来解释“管程”的基本思想。 1.什么是管程 管程可以被认为是一个建筑物,其中包含一个特殊的房间(下图的special room)。该特殊的房间在同一时间只能由一个客户(线程...
  • Java 同步方法

    千次阅读 2019-05-19 15:19:58
    Java同步方法 接着上篇博客多线程,继续分析解决 线程同步 的两个方法:同步块 和 同步方法 中的 同步方法。用 synchronized 关键字给针对共享资源进行操作的方法加锁。一个方法使用 synchronized 关键字修饰后,...
  • Java同步技术

    千次阅读 2008-11-12 15:07:00
    Java同步技术 文/ Iangao 2008.10.9 一基本同步原理1. .基本同步原理2. 信号量(Semphore)二. 高级同步技术1. 事件(Event)2. 管程(Monitor)与条件变量(Condition)3. 信号量、事件以及条件变量之间异同三. 经典同步...
  • java同步队列,包括非阻塞队列与阻塞队列
  • Java同步块用来避免竞争。本文介绍以下内容: Java同步关键字(synchronzied) 实例方法同步 静态方法同步 实例方法中同步块 静态方法中同步块 Java同步示例 Java 同步关键字...
  • java同步synchronized

    万次阅读 2019-09-20 15:59:31
    java同步synchronized     volatile 仅仅用来保证该变量对所有线程的可见性,但不保证原子性。     看 下面的这段代码: /** * * @author InJavaWeTrust * */ public class CountVolatile ...
  • java 同步锁(synchronized)

    万次阅读 多人点赞 2013-10-12 15:30:43
    java 同步锁(synchronized)
  • C#与Java同步加密解密DES算法

    千次阅读 2016-12-30 10:21:10
    在实际项目中,往往前端和后端使用不同的语言。比如使用C#开发客户端,使用Java开发服务器端。有时出于安全性考虑需要将字符加密传输后,由服务器解密获取。本文介绍一种采用DES算法的C#与Java同步加密解密的代码。
  • Java 同步机制

    千次阅读 2018-07-13 22:52:21
    Java中提供了同步机制,可以有效地防止资源冲突。同步机制使用synchronized关键字。 同步块 synchronized(Object){ }注意在初始化Object对象时,不要将其定义在run()方法中,应该将其定义在run()方法外(看...
  • 2021版Java同步器教程

    2021-08-04 14:47:28
  • 关于MySql的数据同步,一般的方法是读取mysql的日志binlog文件,来获取数据的变更,进行同步的。       现在开源的项目中有监听mysql binlog的工具有很多: mysql-binlog-...
  • C03-Java同步实践加强班

    千次阅读 2012-09-06 10:10:04
    C03-Java同步实践加强班  活动安排:结合2011级同学正在开出的Java课程,每周共同要完成的一定量的拓展实践题目,获得高于课程基本要求的编程能力。  适合对象:Java课程中的实践要求“喂”不饱你?在...
  • JAVA同步队列

    千次阅读 2018-04-17 12:01:48
    代码同步1. ConcurrentHashMap 采用分段方式减少锁粒度,提高并发性能。get时没有锁。2. Copy-On-Write 读写分离,适合于读多于写的场合。JDK里的COW容器有两种:CopyOnWriteArrayList和CopyOnWriteArraySet。3....
  • Java 同步方式 (1) —— synchronized

    万次阅读 2012-06-19 00:02:45
    前两篇博客 ArrayList 用法比较 和 String 用法比较,介绍过程中都提及到了同步和线程安全的问题,本篇将重点介绍Java同步方式之一的synchronized用法。线程安全线程安全,是指每次运行结果和单线程运行的结果是...
  • java同步方法和同步代码块

    万次阅读 多人点赞 2017-01-18 14:45:38
     一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时,一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。  
  • 区别: 同步方法默认用this或者当前类class对象作为锁; 同步代码块可以选择以什么来加锁,比同步方法要更细颗粒度,我们可以选择只同步会发生同步问题的部分代码而不是整个方法...java允许多线程并发控制,当多个线...
  • Java同步代码转异步代码

    千次阅读 2009-11-18 11:19:00
    Java同步代码转异步代码Kagula2009-11-18摘要Thread Thread Group概要 利用Java源码,介绍同步代码转异步代码框架的使用,下半部份附框架源代码,阅读本文之前可以参考《Java多线程_编程模型研究》...
  • java同步和互斥

    千次阅读 2012-05-31 22:38:33
    Java关键字synchronized是Java 语言提供的对多线程和同步的一种机制。synchronized可以作为函数的修饰符,也可作为函数内的语句。它可以作用于instance变量,对象引用(object reference),static函数和类名称...
  • Ldap Java同步用户

    千次阅读 2017-11-20 19:12:15
    Java操作LDAP有几种方法,这里主要介绍的是JNDI包,就是它: com.sun.jndi.ldap.LdapCtxFactory LDAP默认情况下使用的是BDB数据库,所以呢,操作LDAP就和操作数据库一样,要分几步走: 1、先导入所需的包,如下...
  • 实际项目开发中所应用到的场景:每次同步数据时,先删除另一个库中表的数据,再同步。 前提:两个库中的表结构一致;本次所用的是mysql数据库;持久化框架为 mybatis;项目框架spring boot /** * 同步数据到另...
  • 【感谢胡光老师提供题目】(回到C03-Java同步实践加强班学习安排)1.继承的练习(1)封装一个People类型,具有height和weight属性,具有speakHello、averageHeight、averageWeight功能。(2)封装一类ChinaPeople类型...
  • Java同步之synchronized

    万次阅读 2013-02-04 20:58:30
    Java中可以使用关键字synchronized进行线程同步控制,实现关键资源顺序访问,避免由于多线程并发执行导致的数据不一致性等问题。synchronized的原理是对象监视器(锁),只有获取到监视器的线程才能继续执行,否则...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 814,518
精华内容 325,807
关键字:

java同步

java 订阅