`

synchronized(this)理解

synchronized(this)的理解 
阅读更多

1、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。

2、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问object中的非synchronized(this)同步代码块。

3、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其他synchronized(this)同步代码块得访问将被阻塞。

4、第三个例子同样适用其他同步代码块。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其他线程对该object对象所有同步代码部分的访问都将被暂时阻塞。

5、以上规则对其他对象锁同样适用

 

一、

Java代码  收藏代码
  1. public class Thread1 implements Runnable{  
  2.   
  3.     /** 
  4.      * 一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。 
  5.      * 另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块 
  6.      * @param args 
  7.      */  
  8.     public static void main(String[] args) {  
  9.         Thread1 t1=new Thread1();  
  10.         Thread ta=new Thread(t1,"A");  
  11.         Thread tb=new Thread(t1,"B");  
  12.         ta.start();  
  13.         tb.start();  
  14.     }  
  15.   
  16.     @Override  
  17.     public void run() {  
  18.         synchronized(this){  
  19.             for(int i=0;i<5;i++){  
  20.                 System.out.println(Thread.currentThread().getName()+" synchronized loop "+i);  
  21.             }  
  22.         }  
  23.     }  
  24.   
  25. }  

 执行结果：

     A synchronized loop 0
     A synchronized loop 1
     A synchronized loop 2
     A synchronized loop 3
     A synchronized loop 4
     B synchronized loop 0
     B synchronized loop 1
     B synchronized loop 2
     B synchronized loop 3

     B synchronized loop 4

二、

Java代码  收藏代码
  1. package review.testSynchronized;  
  2.   
  3. public class Thread2 implements Runnable {  
  4.   
  5.     /** 
  6.      * 然而，当一个线程访问object的一个synchronized(this)同步代码块时， 
  7.      * 另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。 
  8.      * @param args 
  9.      */  
  10.     public static void main(String[] args) {  
  11.         final Thread2 myt2=new Thread2();  
  12.         Thread t1=new Thread(  
  13.         new Runnable(){  
  14.             public void run(){  
  15.                 myt2.m4t1();  
  16.             }  
  17.         },"t1"  
  18.         );  
  19.         Thread t2=new Thread(  
  20.                 new Runnable(){  
  21.                     public void run(){  
  22.                         myt2.m4t2();  
  23.                     }  
  24.                 },"t2"  
  25.                 );  
  26.         t1.start();  
  27.         t2.start();  
  28.     }  
  29.     public void m4t1(){  
  30.         synchronized(this){  
  31.             int i=5;  
  32.             while(i-->0){  
  33.                 System.out.println(Thread.currentThread().getName()+" : "+i);  
  34.             }  
  35.             try {  
  36.                 Thread.sleep(500);  
  37.             } catch (InterruptedException e) {  
  38.                 e.printStackTrace();  
  39.             }  
  40.         }  
  41.     }  
  42.     public void m4t2(){  
  43.         int i=5;  
  44.         while(i-->0){  
  45.             System.out.println(Thread.currentThread().getName()+" : "+i);  
  46.         }  
  47.         try {  
  48.             Thread.sleep(500);  
  49.         } catch (InterruptedException e) {  
  50.             e.printStackTrace();  
  51.         }  
  52.     }  
  53.     @Override  
  54.     public void run() {  
  55.           
  56.     }  
  57.   
  58. }  

 

 执行结果：

     t1 : 4
     t1 : 3
     t1 : 2
     t1 : 1
     t2 : 4
     t2 : 3
     t2 : 2
     t2 : 1
     t2 : 0
     t1 : 0


 

三、

Java代码  收藏代码
  1. package review.testSynchronized;  
  2.   
  3. public class Thread3 {  
  4.   
  5.     /** 
  6.      * 三、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时， 
  7.      * 其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。 
  8.      * @param args 
  9.      */  
  10.     public static void main(String[] args) {  
  11.         final Thread3 myt2=new Thread3();  
  12.         Thread t1=new Thread(  
  13.         new Runnable(){  
  14.             public void run(){  
  15.                 myt2.m4t1();  
  16.             }  
  17.         },"Thread3_t1"  
  18.         );  
  19.         Thread t2=new Thread(  
  20.                 new Runnable(){  
  21.                     public void run(){  
  22.                         myt2.m4t2();  
  23.                     }  
  24.                 },"Thread3_t2"  
  25.                 );  
  26.         t1.start();  
  27.         t2.start();  
  28.     }  
  29.     public void m4t1(){  
  30.         synchronized(this){  
  31.             int i=5;  
  32.             while(i-->0){  
  33.                 System.out.println(Thread.currentThread().getName()+" : "+i);  
  34.             }  
  35.             try {  
  36.                 Thread.sleep(500);  
  37.             } catch (InterruptedException e) {  
  38.                 e.printStackTrace();  
  39.             }  
  40.         }  
  41.     }  
  42.     public void m4t2(){  
  43.         synchronized(this){  
  44.             int i=5;  
  45.             while(i-->0){  
  46.                 System.out.println(Thread.currentThread().getName()+" : "+i);  
  47.             }  
  48.             try {  
  49.                 Thread.sleep(500);  
  50.             } catch (InterruptedException e) {  
  51.                 e.printStackTrace();  
  52.             }  
  53.         }  
  54.           
  55.     }  
  56. }  

 执行结果：

 

     Thread3_t1 : 4
     Thread3_t1 : 3
     Thread3_t1 : 2
     Thread3_t1 : 1
     Thread3_t1 : 0
     Thread3_t2 : 4
     Thread3_t2 : 3
     Thread3_t2 : 2
     Thread3_t2 : 1
     Thread3_t2 : 0 

 

四、

Java代码  收藏代码
  1. package review.testSynchronized;  
  2.   
  3. public class Thread4 {  
  4.   
  5.     /** 
  6.      * 四、第三个例子同样适用其它同步代码块。 
  7.      * 也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。 
  8.      * 结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。 
  9.      * @param args 
  10.      */  
  11.     public static void main(String[] args) {  
  12.         final Thread4 myt4=new Thread4();  
  13.         Thread t1=new Thread(  
  14.         new Runnable(){  
  15.             public void run(){  
  16.                 myt4.m4t1();  
  17.             }  
  18.         },"Thread4_t1"  
  19.         );  
  20.         Thread t2=new Thread(  
  21.                 new Runnable(){  
  22.                     public void run(){  
  23.                         myt4.m4t2();  
  24.                     }  
  25.                 },"Thread4_t2"  
  26.                 );  
  27.         t1.start();  
  28.         t2.start();  
  29.     }  
  30.     public void m4t1(){  
  31.         synchronized(this){  
  32.             int i=5;  
  33.             while(i-->0){  
  34.                 System.out.println(Thread.currentThread().getName()+" : "+i);  
  35.             }  
  36.             try {  
  37.                 Thread.sleep(500);  
  38.             } catch (InterruptedException e) {  
  39.                 e.printStackTrace();  
  40.             }  
  41.         }  
  42.     }  
  43.     public synchronized void m4t2(){  
  44.             int i=5;  
  45.             while(i-->0){  
  46.                 System.out.println(Thread.currentThread().getName()+" : "+i);  
  47.             }  
  48.             try {  
  49.                 Thread.sleep(500);  
  50.             } catch (InterruptedException e) {  
  51.                 e.printStackTrace();  
  52.             }  
  53.           
  54.     }  
  55. }  

 

执行结果：

     Thread4_t1 : 4
     Thread4_t1 : 3
     Thread4_t1 : 2
     Thread4_t1 : 1
     Thread4_t1 : 0
     Thread4_t2 : 4
     Thread4_t2 : 3
     Thread4_t2 : 2
     Thread4_t2 : 1
     Thread4_t2 : 0

 

 五、

Java代码  收藏代码
  1. package review.testSynchronized;  
Java代码  收藏代码
  1. public class Thread5 {  
Java代码  收藏代码
  1.  /** 
  2.   * @param args 
  3.   */  
  4.  public static void main(String[] args) {  
  5.   final Thread5 myt5=new Thread5();  
  6.   final Inner inner=myt5.new Inner();  
  7.   Thread t1=new Thread(new Runnable(){  
  8.    public void run(){  
  9.     myt5.m4t1(inner);  
  10.    }  
  11.   },"Thread5_t1"  
  12.      );  
  13.   Thread t2=new Thread(new Runnable(){  
  14.    public void run(){  
  15.     myt5.m4t2(inner);  
  16.    }  
  17.   },"Thread5_t2"  
  18.      );  
  19.   t1.start();  
  20.   t2.start();  
  21.  }  
  22.     class Inner{  
  23.      private void m4t1(){  
  24.       int i=5;  
  25.       while(i-->0){  
  26.        System.out.println(Thread.currentThread().getName()+":Inner.m4t1()="+i);  
  27.        try{  
  28.         Thread.sleep(500);  
  29.        }catch(Exception e){  
  30.           
  31.        }  
  32.       }  
  33.      }  
  34.      private void m4t2(){  
  35.          int i=5;  
  36.          while(i-->0){  
  37.           System.out.println(Thread.currentThread().getName()+":Inner.m4t2()="+i);  
  38.           try{  
  39.               Thread.sleep(500);  
  40.              }catch(Exception e){    
  41.              }  
  42.          }  
  43.         }  
  44.     }  
  45.     private void m4t1(Inner inner){  
  46.      synchronized(inner){//使用对象锁  
  47.      inner.m4t1();  
  48.      }  
  49.     }  
  50.     private void m4t2(Inner inner){  
  51.      inner.m4t2();  
  52.     }  
  53.       
  54. }  

 

执行结果：

（尽管t1获得了对Inner的对象锁，但由于线程t2 访问的是同一个inner的非同步部分。所所以两个线程互不干扰）

     Thread5_t1:Inner.m4t1()=4
     Thread5_t2:Inner.m4t2()=4
     Thread5_t2:Inner.m4t2()=3
     Thread5_t1:Inner.m4t1()=3
     Thread5_t2:Inner.m4t2()=2
     Thread5_t1:Inner.m4t1()=2
     Thread5_t2:Inner.m4t2()=1
     Thread5_t1:Inner.m4t1()=1
     Thread5_t1:Inner.m4t1()=0
     Thread5_t2:Inner.m4t2()=0

 

现在在Inner.m4t2()前面加上synchronized:

(尽管t1与t2访问了同一个对象中两个毫不相干的部分，但因为t1先获得了对对象Inner的对象锁，所以t2对Inner.m4t2()的访问也被阻塞，因为m4t2()是Inner中的一个同步方法)

     Thread5_t1:Inner.m4t1()=4
     Thread5_t1:Inner.m4t1()=3
     Thread5_t1:Inner.m4t1()=2
     Thread5_t1:Inner.m4t1()=1
     Thread5_t1:Inner.m4t1()=0
     Thread5_t2:Inner.m4t2()=4
     Thread5_t2:Inner.m4t2()=3
     Thread5_t2:Inner.m4t2()=2
     Thread5_t2:Inner.m4t2()=1
     Thread5_t2:Inner.m4t2()=0

 

分享到：
| solr4整合ikanalyze
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    synchronized 的理解

    这意味着在任意时刻，都只有一个线程可以访问该实例的所有`synchronized`方法，或者进入由`synchronized(this)`标记的代码块。对于静态方法，锁对象则是该类的Class对象。 ```java public class MyClass { private...

    java的线程同步机制synchronized关键字的理解_.docx

    Java 线程同步机制中 synchronized 关键字的理解 Java 的线程同步机制是为了解决多个线程共享同一片存储空间所带来的访问冲突问题。其中，synchronized 关键字是 Java 语言中解决这种冲突的重要机制。 ...

    深入理解java中的synchronized关键字

    - 如果一个线程在一个对象的`synchronized(this)`块中，其他线程仍然可以访问该对象的非`synchronized(this)`代码块。 - 对象锁仅适用于该对象的`synchronized`代码块，不影响其他线程对其他对象的访问。 以下是...

    Android synchronized 测试案例

    synchronized (this) { // 代码块 } } ``` 在上述案例中，`this`表示当前对象实例，也可以替换为其他对象实例，实现对特定对象的同步。 三、同步多个对象 在多对象同步中，可以通过锁定不同的对象实例来实现对...

    synchronized用法大全实例

    在Java多线程编程中，`synchronized`关键字是一个至关重要的工具，用于实现线程间的同步，以确保共享资源的安全访问。本实例大全将全面解析`...理解并熟练使用`synchronized`，是编写健壮的多线程Java程序的基础。

    JAVA synchronized详解

    为了更好地理解`synchronized`的工作原理，我们来看两个示例。 ##### 示例1：同步方法 下面的代码展示了一个使用同步方法的例子，其中定义了一个`Thread1`类，实现了`Runnable`接口。在这个类中，`run()`方法被`...

    synchronized详解

    理解`synchronized`的关键在于识别它锁定的是哪个对象。在方法级别，锁是`this`或`static`方法所属的Class对象；在同步块中，锁是块内指定的对象。同时，应该谨慎使用`synchronized`，因为它会引入性能开销，并可能...

    java synchronized demo

    在Java编程语言中，`...总结，`java synchronized demo`是一个关于如何在Java中使用`synchronized`关键字进行线程同步的示例，通过理解和实践这个例子，开发者可以更好地掌握多线程环境下数据安全和同步的重要性。

    javasynchronized详解.pdf

    Java中的`synchronized`关键字是用于实现线程同步的重要机制，它的主要目的是确保在多线程环境中，对于共享资源的访问能够保持线程安全。...理解并熟练运用`synchronized`可以帮助开发者编写出更加健壮的多线程程序。

    java-synchronized详解.doc

    例子二展示了即使在一个线程执行`synchronized(this)`代码块时，其他线程仍可以访问同一个对象中的非`synchronized`方法。线程A执行`synchronized`方法`m4t1()`，线程B可以同时执行非`synchronized`方法`m4t2()`。 ...

    JAVA面试题 简谈你对synchronized关键字的理解

    JAVA面试题简谈你对synchronized关键字的理解 Synchronized关键字是Java语言中的一种同步机制，主要用于解决多线程之间的同步问题。下面我们将详细介绍synchronized关键字的特性、用法和注意事项。 Synchronized...

    Java synchronized关键_动力节点Java学院整理

    在提供的示例中，`MyRunable`类的`run()`方法使用`synchronized(this)`代码块，这里的`this`指的是`MyRunable`对象。由于`t1`和`t2`都基于同一个`Runnable`对象`demo`创建，所以它们共享`demo`的锁。当一个线程执行`...

    同步代码块(synchronized).zip

    在Java编程语言中，同步...理解并熟练使用`synchronized`关键字是Java多线程编程的基础，对于开发高效且线程安全的程序至关重要。在实际工作中，我们需要根据具体需求灵活运用同步代码块，以确保系统的正确性和稳定性。

    Javasynchronized机制.pdf

    在Java编程语言中，`synchronized`关键字是用于处理多线程并发访问共享资源时的同步控制机制。它确保了在同一时刻，...理解`synchronized`的工作原理以及如何正确应用它，对于编写健壮的多线程Java应用程序至关重要。

    使用synchronized实现多线程同步.pdf

    在Java编程中，多线程同步是一个至关重要的概念，它确保了多个线程在访问共享资源时能够有序进行，防止数据不一致性和竞态条件。...理解和正确使用`synchronized`对于构建可靠的并发程序至关重要。

    实例解析Java中的synchronized关键字与线程平安问题_.docx

    但是，很多开发者对 synchronized 关键字的理解并不够深入，本文将通过实例解析 Java 中的 synchronized 关键字与线程平安问题，帮助开发者更好地理解和使用 synchronized 关键字。 首先，需要清晰的是 ...

    并发编程原理学习：synchronized关键字.doc

    并发编程是多线程环境下确保...理解并熟练运用`synchronized`，可以帮助开发者编写出更加健壮的多线程程序。然而，过度依赖`synchronized`可能会导致性能问题，因此在实际应用中，应结合业务场景选择合适的同步策略。

    Java 同步示例介绍.doc

    首先，我们来看一个具体的例子来更好地理解`synchronized(this)`的用法。考虑以下场景：两个并发线程访问同一个对象（`this`）中的`synchronized(this)`同步代码块。 ```java package ts; public class Thread1 ...

    PHP pthreads v3下同步处理synchronized用法示例

    $this-&gt;synchronized(function () { for ($i = 0; $i ; $i++) { ++$this-&gt;cnt; } }); } } ``` 在这个例子中，`add`方法中的整个for循环被`synchronized`包裹，确保每次只有一个线程能执行这段代码，从而避免...

    Java线程及同步（synchronized）样例代码

    通过具体的代码实现，我们将深入理解Java中的线程同步机制，并学习如何在实际编程中正确地使用这些机制。 #### 二、核心概念与原理 ##### 1. Java线程基础 Java中的线程是程序执行的基本单位，每个线程有自己的...

Magicbox
Global site tag (gtag.js) - Google Analytics