• 设为首页收藏本站
  • 联系投稿 版权声明
    • 首页 热点 明星 影视 音乐 综艺 娱乐 生活时尚
    当前位置：首页 > 影视 > 正文

    Java多线程之synchronized关键字详解

    Date：2017-05-28 21:39:50   来源：Android开发中文站

    Java多线程之synchronized关键字详解

    多线程的同步机制对资源进行加锁，使得在同一个时间，只有一个线程可以进行操作，同步用以解决多个线程同时访问时可能出现的问题。

    同步机制可以使用synchronized关键字实现。

    当synchronized关键字修饰一个方法的时候，该方法叫做同步方法。

    当synchronized方法执行完或发生异常时，会自动释放锁。

    下面通过一个例子来对synchronized关键字的用法进行解析。

    1，是否使用synchronized关键字的不同

    1. public class ThreadTest 
    2. { 
    3.     public static void main(String[] args) 
    4.     { 
    5.         Example example = new Example(); 
    6.  
    7.         Thread t1 = new Thread1(example); 
    8.         Thread t2 = new Thread1(example); 
    9.  
    10.         t1.start(); 
    11.         t2.start(); 
    12.     } 
    13.  
    14. } 
    15.  
    16. class Example 
    17. { 
    18.     public synchronized void execute() 
    19.     { 
    20.         for (int i = 0; i < 10; ++i) 
    21.         { 
    22.             try 
    23.             { 
    24.                 Thread.sleep(500); 
    25.             } 
    26.             catch (InterruptedException e) 
    27.             { 
    28.                 e.printStackTrace(); 
    29.             } 
    30.             System.out.println("Hello: " + i); 
    31.         } 
    32.     } 
    33.  
    34. } 
    35.  
    36. class Thread1 extends Thread 
    37. { 
    38.     private Example example; 
    39.  
    40.     public Thread1(Example example) 
    41.     { 
    42.         this.example = example; 
    43.     } 
    44.  
    45.     @Override 
    46.     public void run() 
    47.     { 
    48.         example.execute(); 
    49.     } 
    50.  
    51. } 

    是否在execute()方法前加上synchronized关键字，这个例子程序的执行结果会有很大的不同。

    如果不加synchronized关键字，则两个线程同时执行execute()方法，输出是两组并发的。

    如果加上synchronized关键字，则会先输出一组0到9，然后再输出下一组，说明两个线程是顺次执行的。

    2.多个方法的多线程情况

    将程序改动一下，Example类中再加入一个方法execute2()。

    之后再写一个线程类Thread2，Thread2中的run()方法执行的是execute2()。Example类中的两个方法都是被synchronized关键字修饰的。

    1. public class ThreadTest 
    2. { 
    3.     public static void main(String[] args) 
    4.     { 
    5.         Example example = new Example(); 
    6.  
    7.         Thread t1 = new Thread1(example); 
    8.         Thread t2 = new Thread2(example); 
    9.  
    10.         t1.start(); 
    11.         t2.start(); 
    12.     } 
    13.  
    14. } 
    15.  
    16. class Example 
    17. { 
    18.     public synchronized void execute() 
    19.     { 
    20.         for (int i = 0; i < 20; ++i) 
    21.         { 
    22.             try 
    23.             { 
    24.                 Thread.sleep((long) Math.random() * 1000); 
    25.             } 
    26.             catch (InterruptedException e) 
    27.             { 
    28.                 e.printStackTrace(); 
    29.             } 
    30.             System.out.println("Hello: " + i); 
    31.         } 
    32.     } 
    33.  
    34.     public synchronized void execute2() 
    35.     { 
    36.         for (int i = 0; i < 20; ++i) 
    37.         { 
    38.             try 
    39.             { 
    40.                 Thread.sleep((long) Math.random() * 1000); 
    41.             } 
    42.             catch (InterruptedException e) 
    43.             { 
    44.                 e.printStackTrace(); 
    45.             } 
    46.             System.out.println("World: " + i); 
    47.         } 
    48.     } 
    49.  
    50. } 
    51.  
    52. class Thread1 extends Thread 
    53. { 
    54.     private Example example; 
    55.  
    56.     public Thread1(Example example) 
    57.     { 
    58.         this.example = example; 
    59.     } 
    60.  
    61.     @Override 
    62.     public void run() 
    63.     { 
    64.         example.execute(); 
    65.     } 
    66.  
    67. } 
    68.  
    69. class Thread2 extends Thread 
    70. { 
    71.     private Example example; 
    72.  
    73.     public Thread2(Example example) 
    74.     { 
    75.         this.example = example; 
    76.     } 
    77.  
    78.     @Override 
    79.     public void run() 
    80.     { 
    81.         example.execute2(); 
    82.     } 
    83.  
    84. } 

    如果去掉synchronized关键字，则两个方法并发执行，并没有相互影响。

    但是如例子程序中所写，即便是两个方法：

    执行结果永远是执行完一个线程的输出再执行另一个线程的。

    说明：

    如果一个对象有多个synchronized方法，某一时刻某个线程已经进入到了某个synchronized方法，那么在该方法没有执行完毕前，其他线程是无法访问该对象的任何synchronized方法的。

    结论：

    当synchronized关键字修饰一个方法的时候，该方法叫做同步方法。

    Java中的每个对象都有一个锁(lock)，或者叫做监视器(monitor)，当一个线程访问某个对象的synchronized方法时，将该对象上锁，其他任何线程都无法再去访问该对象的synchronized方法了(这里是指所有的同步方法，而不仅仅是同一个方法)，直到之前的那个线程执行方法完毕后(或者是抛出了异常)，才将该对象的锁释放掉，其他线程才有可能再去访问该对象的synchronized方法。

    注意这时候是给对象上锁，如果是不同的对象，则各个对象之间没有限制关系。

    尝试在代码中构造第二个线程对象时传入一个新的Example对象，则两个线程的执行之间没有什么制约关系。

    3.考虑静态的同步方法

    当一个synchronized关键字修饰的方法同时又被static修饰，之前说过，非静态的同步方法会将对象上锁，但是静态方法不属于对象，而是属于类，它会将这个方法所在的类的Class对象上锁。

    一个类不管生成多少个对象，它们所对应的是同一个Class对象。

    1. public class ThreadTest 
    2. { 
    3.     public static void main(String[] args) 
    4.     { 
    5.         Example example = new Example(); 
    6.  
    7.         Thread t1 = new Thread1(example); 
    8.  
    9.         // 此处即便传入不同的对象，静态方法同步仍然不允许多个线程同时执行 
    10.         example = new Example(); 
    11.  
    12.         Thread t2 = new Thread2(example); 
    13.  
    14.         t1.start(); 
    15.         t2.start(); 
    16.     } 
    17.  
    18. } 
    19.  
    20. class Example 
    21. { 
    22.     public synchronized static void execute() 
    23.     { 
    24.         for (int i = 0; i < 20; ++i) 
    25.         { 
    26.             try 
    27.             { 
    28.                 Thread.sleep((long) Math.random() * 1000); 
    29.             } 
    30.             catch (InterruptedException e) 
    31.             { 
    32.                 e.printStackTrace(); 
    33.             } 
    34.             System.out.println("Hello: " + i); 
    35.         } 
    36.     } 
    37.  
    38.     public synchronized static void execute2() 
    39.     { 
    40.         for (int i = 0; i < 20; ++i) 
    41.         { 
    42.             try 
    43.             { 
    44.                 Thread.sleep((long) Math.random() * 1000); 
    45.             } 
    46.             catch (InterruptedException e) 
    47.             { 
    48.                 e.printStackTrace(); 
    49.             } 
    50.             System.out.println("World: " + i); 
    51.         } 
    52.     } 
    53.  
    54. } 
    55.  
    56. class Thread1 extends Thread 
    57. { 
    58.     private Example example; 
    59.  
    60.     public Thread1(Example example) 
    61.  
    62.     { 
    63.         this.example = example; 
    64.     } 
    65.  
    66.     @Override 
    67.     public void run() 
    68.     { 
    69.         Example.execute(); 
    70.     } 
    71.  
    72. } 
    73.  
    74. class Thread2 extends Thread 
    75. { 
    76.     private Example example; 
    77.  
    78.     public Thread2(Example example) 
    79.     { 
    80.         this.example = example; 
    81.     } 
    82.  
    83.     @Override 
    84.     public void run() 
    85.     { 
    86.         Example.execute2(); 
    87.     } 
    88.  
    89. } 

    所以如果是静态方法的情况(execute()和execute2()都加上static关键字)，即便是向两个线程传入不同的Example对象，这两个线程仍然是互相制约的，必须先执行完一个，再执行下一个。

    结论：

    如果某个synchronized方法是static的，那么当线程访问该方法时，它锁的并不是synchronized方法所在的对象，而是synchronized方法所在的类所对应的Class对象。Java中，无论一个类有多少个对象，这些对象会对应唯一一个Class对象，因此当线程分别访问同一个类的两个对象的两个static，synchronized方法时，它们的执行顺序也是顺序的，也就是说一个线程先去执行方法，执行完毕后另一个线程才开始。

    4. synchronized块

    synchronized块写法：

    synchronized(object)

    {

    }

    表示线程在执行的时候会将object对象上锁。(注意这个对象可以是任意类的对象，也可以使用this关键字)。

    这样就可以自行规定上锁对象。

    1. public class ThreadTest 
    2. { 
    3.     public static void main(String[] args) 
    4.     { 
    5.         Example example = new Example(); 
    6.  
    7.         Thread t1 = new Thread1(example); 
    8.         Thread t2 = new Thread2(example); 
    9.  
    10.         t1.start(); 
    11.         t2.start(); 
    12.     } 
    13.  
    14. } 
    15.  
    16. class Example 
    17. { 
    18.     private Object object = new Object(); 
    19.  
    20.     public void execute() 
    21.     { 
    22.         synchronized (object) 
    23.         { 
    24.             for (int i = 0; i < 20; ++i) 
    25.             { 
    26.                 try 
    27.                 { 
    28.                     Thread.sleep((long) Math.random() * 1000); 
    29.                 } 
    30.                 catch (InterruptedException e) 
    31.                 { 
    32.                     e.printStackTrace(); 
    33.                 } 
    34.                 System.out.println("Hello: " + i); 
    35.             } 
    36.  
    37.         } 
    38.  
    39.     } 
    40.  
    41.     public void execute2() 
    42.     { 
    43.         synchronized (object) 
    44.         { 
    45.             for (int i = 0; i < 20; ++i) 
    46.             { 
    47.                 try 
    48.                 { 
    49.                     Thread.sleep((long) Math.random() * 1000); 
    50.                 } 
    51.                 catch (InterruptedException e) 
    52.                 { 
    53.                     e.printStackTrace(); 
    54.                 } 
    55.                 System.out.println("World: " + i); 
    56.             } 
    57.  
    58.         } 
    59.  
    60.     } 
    61.  
    62. } 
    63.  
    64. class Thread1 extends Thread 
    65. { 
    66.     private Example example; 
    67.  
    68.     public Thread1(Example example) 
    69.     { 
    70.         this.example = example; 
    71.     } 
    72.  
    73.     @Override 
    74.     public void run() 
    75.     { 
    76.         example.execute(); 
    77.     } 
    78.  
    79. } 
    80.  
    81. class Thread2 extends Thread 
    82. { 
    83.     private Example example; 
    84.  
    85.     public Thread2(Example example) 
    86.     { 
    87.         this.example = example; 
    88.     } 
    89.  
    90.     @Override 
    91.     public void run() 
    92.     { 
    93.         example.execute2(); 
    94.     } 
    95.  
    96. } 

    例子程序4所达到的效果和例子程序2的效果一样，都是使得两个线程的执行顺序进行，而不是并发进行，当一个线程执行时，将object对象锁住，另一个线程就不能执行对应的块。

    synchronized方法实际上等同于用一个synchronized块包住方法中的所有语句，然后在synchronized块的括号中传入this关键字。当然，如果是静态方法，需要锁定的则是class对象。

    可能一个方法中只有几行代码会涉及到线程同步问题，所以synchronized块比synchronized方法更加细粒度地控制了多个线程的访问，只有synchronized块中的内容不能同时被多个线程所访问，方法中的其他语句仍然可以同时被多个线程所访问(包括synchronized块之前的和之后的)。

    注意：被synchronized保护的数据应该是私有的。

    结论：

    synchronized方法是一种粗粒度的并发控制，某一时刻，只能有一个线程执行该synchronized方法;

    synchronized块则是一种细粒度的并发控制，只会将块中的代码同步，位于方法内、synchronized块之外的其他代码是可以被多个线程同时访问到的。

    JDK 5.0的并发包

    使用synchronized关键字解决线程的同步问题会带来一些执行效率上的问题。

    JDK1.4及之前是无法避免这些问题的。

    JDK 5.0引入了这样一个包：java.util.concurrent：

    http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/package-frame.html

    专门解决这一问题。

    限于篇幅，这里不再介绍。


    上一篇：小米6小弟！疑似小米6C现身
    下一篇：冷眼看快手、陌陌们的“短视频社交”

    推荐阅读

    24小时新闻热点

    图片推荐

    首页 | 热点 | 明星 | 影视 | 音乐 | 综艺 | 娱乐 | 生活时尚
  • Copyright @ 2017 www.entcn.com.cn, All Rights Reserved 版权所有：娱乐中国网
    欢迎广大网友来本网站投稿，网站内容来自于互联网或网友提供