zoukankan      html  css  js  c++  java

  • Android（java）同步方法synchronized

    synchronized 是java语言keyword。当它用来修饰一个方法或者一个代码块的时候，可以保证在同一时刻最多仅仅有一个线程运行该段代码。

    synchronized keyword，它包含两种使用方法：synchronized 方法和 synchronized 块。  

    本文直接以代码的形式来展示 synchronized keyword的使用：

    【1】synchronized  Demo1：

    [html] view plaincopy
    1. package com.andyidea.demo;  
    2.   
    3. /**  
    4.  * 当两个并发线程訪问同一个对象object中的这个synchronized(this)同步代码块时，  
    5.  * 一个时间内仅仅能有一个线程得到运行。还有一个线程必须等待当前线程运行完这个代码  
    6.  * 块以后才干运行该代码块。  
    7.  * @author Andy.Chen  
    8.  *  
    9.  */  
    10. public class Thread01 implements Runnable {  
    11.   
    12.     @Override  
    13.     public void run() {  
    14.   
    15.         synchronized (this) {  
    16.             for(int i=0;i<3;i++){  
    17.                 System.out.println(Thread.currentThread().getName()+" synchronized loop "+i);  
    18.             }  
    19.         }  
    20.     }  
    21.       
    22.     public static void main(String[] args) {  
    23.         Thread01 t01 = new Thread01();  
    24.           
    25.         System.out.println("synchronized keyword使用  "  
    26.                   +"--------------------------");  
    27.           
    28.         Thread ta = new Thread(t01,"A");  
    29.         Thread tb = new Thread(t01,"B");  
    30.           
    31.         ta.start();  
    32.         tb.start();  
    33.     }  
    34.   
    35. }  

    执行结果例如以下：

    [html] view plaincopy

    2. synchronized keyword使用   
    3. --------------------------  
    4. B synchronized loop 0  
    5. B synchronized loop 1  
    6. B synchronized loop 2  
    7. A synchronized loop 0  
    8. A synchronized loop 1  
    9. A synchronized loop 2  

    【2】synchronized  Demo2：

    [html] view plaincopy
    1. package com.andyidea.demo;  
    2.   
    3. /**  
    4.  * 当一个线程訪问object的一个synchronized(this)同步代码块时，  
    5.  * 还有一个线程仍然能够訪问该object中的非synchronized(this)同步代码块。  
    6.  * @author Andy.Chen  
    7.  *  
    8.  */  
    9. public class Thread02 {  
    10.       
    11.     public void method01(){  
    12.         synchronized (this) {  
    13.             int i=0;  
    14.             while(i++ < 3){  
    15.                 System.out.println(Thread.currentThread().getName() +":"+ i);  
    16.                 try {  
    17.                     Thread.sleep(1000);  
    18.                 } catch (InterruptedException e) {  
    19.                     e.printStackTrace();  
    20.                 }  
    21.             }  
    22.         }  
    23.     }  
    24.       
    25.     public void method02(){  
    26.           
    27.         //第1种方式:当一个线程訪问object的一个synchronized(this)同步代码块时。  
    28.         //还有一个线程仍然能够訪问该object中的非synchronized(this)同步代码块。  
    29. //      int j=0;  
    30. //      while(j++ < 3){  
    31. //          System.out.println(Thread.currentThread().getName() +":"+ j);  
    32. //          try {  
    33. //              Thread.sleep(1000);  
    34. //          } catch (InterruptedException e) {  
    35. //              e.printStackTrace();  
    36. //          }  
    37. //      }  
    38.           
    39.         //第2种方式:当一个线程訪问object的一个synchronized(this)同步代码块时，  
    40.         //其他线程对object中全部其他synchronized(this)同步代码块的訪问将被堵塞。

        

    41.         synchronized (this) {  
    42.             int j=0;  
    43.             while(j++ < 3){  
    44.                 System.out.println(Thread.currentThread().getName() +":"+ j);  
    45.                 try {  
    46.                     Thread.sleep(1000);  
    47.                 } catch (InterruptedException e) {  
    48.                     e.printStackTrace();  
    49.                 }  
    50.             }  
    51.         }  
    52.     }  
    53.       
    54.     /**  
    55.      * 当一个线程訪问object的一个synchronized(this)同步代码块时，  
    56.      * 它就获得了这个object的对象锁。

        

    57.      * 结果，其他线程对该object对象全部同步代码部分的訪问都被临时堵塞。  
    58.      */  
    59.     public synchronized void method3(){  
    60.         int k=0;  
    61.         while(k++ < 3){  
    62.             System.out.println(Thread.currentThread().getName() +":"+ k);  
    63.             try {  
    64.                 Thread.sleep(1000);  
    65.             } catch (InterruptedException e) {  
    66.                 e.printStackTrace();  
    67.             }  
    68.         }  
    69.     }  
    70.       
    71.     public static void main(String[] args) {  
    72.         final Thread02 t02 = new Thread02();  
    73.           
    74.         System.out.println("synchronized keyword使用  "  
    75.                   +"--------------------------");  
    76.           
    77.         Thread t02A = new Thread(new Runnable() {  
    78.               
    79.             @Override  
    80.             public void run() {  
    81.                 t02.method01();  
    82.             }  
    83.         },"A");  
    84.           
    85.         Thread t02B = new Thread(new Runnable() {  
    86.               
    87.             @Override  
    88.             public void run() {  
    89.                 t02.method02();  
    90.             }  
    91.         },"B");  
    92.           
    93.         Thread t02C = new Thread(new Runnable() {  
    94.               
    95.             @Override  
    96.             public void run() {  
    97.                 t02.method3();  
    98.             }  
    99.         },"C");  
    100.           
    101.         t02A.start();  
    102.         t02B.start();  
    103.         t02C.start();  
    104.     }  
    105.   
    106. }  
    执行结果例如以下：

    [html] view plaincopy

    2. synchronized keyword使用   
    3. --------------------------  
    4. B:1  
    5. B:2  
    6. B:3  
    7. C:1  
    8. C:2  
    9. C:3  
    10. A:1  
    11. A:2  
    12. A:3  


    【3】synchronized  Demo3：

    [html] view plaincopy
    1. package com.andyidea.demo;  
    2.   
    3. /**  
    4.  * synchronized对象锁  
    5.  * @author Andy.Chen  
    6.  *  
    7.  */  
    8. public class Thread03 {  
    9.       
    10.     class InnerObject{  
    11.           
    12.         /**  
    13.          * 内部类方法1  
    14.          */  
    15.         private void innerMethod01(){  
    16.             int i=0;  
    17.             while(i++ < 3){  
    18.                 System.out.println(Thread.currentThread().getName() +":"+ i);  
    19.                 try {  
    20.                     Thread.sleep(1000);  
    21.                 } catch (InterruptedException e) {  
    22.                     e.printStackTrace();  
    23.                 }  
    24.             }  
    25.         }  
    26.           
    27.         /**  
    28.          * 内部类方法2  
    29.          */  
    30.         private void innerMethod02(){  
    31.             int j=0;  
    32.             while(j++ < 3){  
    33.                 System.out.println(Thread.currentThread().getName() +":"+ j);  
    34.                 try {  
    35.                     Thread.sleep(1000);  
    36.                 } catch (InterruptedException e) {  
    37.                     e.printStackTrace();  
    38.                 }  
    39.             }  
    40.         }  
    41.     }  
    42.       
    43.     /**  
    44.      * 外部类方法1  
    45.      * @param innerObj  
    46.      */  
    47.     private void outerMethod01(InnerObject innerObj){  
    48.         synchronized (innerObj) {  
    49.             innerObj.innerMethod01();  
    50.         }  
    51.     }  
    52.       
    53.     /**  
    54.      * 外部类方法2  
    55.      * @param innerObj  
    56.      */  
    57.     private void outerMethod02(InnerObject innerObj){  
    58.         innerObj.innerMethod02();  
    59.     }  
    60.       
    61.     public static void main(String[] args) {  
    62.         final Thread03 t03 = new Thread03();  
    63.         final InnerObject innerObj = t03.new InnerObject();  
    64.           
    65.         System.out.println("synchronized keyword使用  "  
    66.                           +"--------------------------");  
    67.   
    68.         Thread t03A = new Thread(new Runnable() {  
    69.               
    70.             @Override  
    71.             public void run() {  
    72.                 t03.outerMethod01(innerObj);  
    73.             }  
    74.         },"A");  
    75.           
    76.         Thread t03B = new Thread(new Runnable() {  
    77.               
    78.             @Override  
    79.             public void run() {  
    80.                 t03.outerMethod02(innerObj);  
    81.             }  
    82.         },"B");  
    83.           
    84.         t03A.start();  
    85.         t03B.start();  
    86.     }  
    87.   
    88. }  
    执行结果例如以下：

    [html] view plaincopy
    1.   
    2. synchronized keyword使用   
    3. --------------------------  
    4. A:1  
    5. B:1  
    6. B:2  
    7. A:2  
    8. B:3  
    9. A:3  

    总结：

    1.  synchronized 方法控制对类成员变量的訪问：每一个类实例相应一把锁，每一个 synchronized 方法都必须获得调用该方法的类实例的锁方能运行。否则所属线程堵塞，方法一旦运行。就独占该锁。直到从该方法返回时才将锁释放。此后被堵塞的线程方能获得该锁。又一次进入可运行状态。

    这样的机制确保了同一时刻对于每一个类实例，其全部声明为 synchronized 的成员函数中至多仅仅有一个处于可运行状态（由于至多仅仅有一个可以获得该类实例相应的锁），从而有效避免了类成员变量的訪问冲突（仅仅要全部可能訪问类成员变量的方法均被声明为 synchronized）。  

    2. synchronized 块是这样一个代码块，当中的代码必须获得对象 syncObject （如前所述，能够是类实例或类）的锁方能运行。

    因为能够针对随意代码块。且可随意指定上锁的对象。故灵活性较高。  

    对synchronized(this)的一些理解 
    一、当两个并发线程訪问同一个对象object中的这个synchronized(this)同步代码块时。一个时间内仅仅能有一个线程得到运行。

    还有一个线程必须等待当前线程运行完这个代码块以后才干运行该代码块。

     

    二、然而。当一个线程訪问object的一个synchronized(this)同步代码块时。还有一个线程仍然能够訪问该object中的非synchronized(this)同步代码块。

     

    三、尤其关键的是。当一个线程訪问object的一个synchronized(this)同步代码块时，其他线程对object中全部其他synchronized(this)同步代码块的訪问将被堵塞。  

    四、当一个线程訪问object的一个synchronized(this)同步代码块时。它就获得了这个object的对象锁。

    结果，其他线程对该object对象全部同步代码部分的訪问都被临时堵塞。
  • 相关阅读:
    两种方法生成随机字符串
    cmd命令总结
    NOI前乱写
    多校模拟9
    字符串 口胡
    HEOI2020游记
    省选模拟104
    省选模拟103
    省选模拟102
    省选模拟101
  • 原文地址：https://www.cnblogs.com/gcczhongduan/p/5375261.html
Copyright © 2011-2022 走看看