Java多线程编程—锁优化

阅读目录

成都创新互联公司是一家专注于成都网站设计、网站建设与策划设计,玛纳斯网站建设哪家好?成都创新互联公司做网站,专注于网站建设10余年,网设计领域的专业建站公司;建站业务涵盖:玛纳斯等地区。玛纳斯做网站价格咨询:13518219792

一、尽量不要锁住方法

二、缩小同步代码块，只锁数据

三、锁中尽量不要再包含锁

四、将锁私有化，在内部管理锁

五、进行适当的锁分解

正文

并发环境下进行编程时，需要使用锁机制来同步多线程间的操作，保证共享资源的互斥访问。加锁会带来性能上的损坏，似乎是众所周知的事情。然而，加锁本身不会带来多少的性能消耗，性能主要是在线程的获取锁的过程。

如果只有一个线程竞争锁，此时并不存在多线程竞争的情况，那么JVM会进行优化，那么这时加锁带来的性能消耗基本可以忽略。因此，规范加锁的操作，优化锁的使用方法，避免不必要的线程竞争，不仅可以提高程序性能，也能避免不规范加锁可能造成线程死锁问题，提高程序健壮性。下面阐述几种锁优化的思路。

一、尽量不要锁住方法

在普通成员函数上加锁时，线程获得的是该方法所在对象的对象锁。此时整个对象都会被锁住。这也意味着，如果这个对象提供的多个同步方法是针对不同业务的，那么由于整个对象被锁住，一个业务业务在处理时，其他不相关的业务线程也必须wait。下面的例子展示了这种情况：

LockMethod类包含两个同步方法，分别在两种业务处理中被调用：

 
 
 
    
  
  
  
  1. public class LockMethod   { 
    2. 
  
  
  
  2.     public synchronized void busiA() { 
    3. 
  
  
  
  3.         for (int i = 0; i < 10000; i++) { 
    4. 
  
  
  
  4.             System.out.println(Thread.currentThread().getName() + "deal with bussiness A:"+i); 
    5. 
  
  
  
  5.         } 
    6. 
  
  
  
  6.     } 
    7. 
  
  
  
  7.     public synchronized void busiB() { 
    8. 
  
  
  
  8.         for (int i = 0; i < 10000; i++) { 
    9. 
  
  
  
  9.             System.out.println(Thread.currentThread().getName() + "deal with bussiness B:"+i); 
    10. 
  
  
  
  10.         } 
    11. 
  
  
  
  11.     } 
    12. 
  
  
  
  12. } 
    13.

BUSSA是线程类，用来处理A业务，调用的是LockMethod的busiA()方法：

 
 
 
    
  
  
  
  1. public class BUSSA extends Thread { 
    2. 
  
  
  
  2.     LockMethod lockMethod; 
    3. 
  
  
  
  3.     void deal(LockMethod lockMethod){ 
    4. 
  
  
  
  4.         this.lockMethod = lockMethod; 
    5. 
  
  
  
  5.     } 
    6. 
  
  
  
  6.  
    7. 
  
  
  
  7.     @Override 
    8. 
  
  
  
  8.     public void run() { 
    9. 
  
  
  
  9.         super.run(); 
    10. 
  
  
  
  10.         lockMethod.busiA(); 
    11. 
  
  
  
  11.     } 
    12. 
  
  
  
  12. } 
    13.

BUSSB是线程类，用来处理B业务，调用的是LockMethod的busiB()方法：

 
 
 
    
  
  
  
  1. public class BUSSB extends Thread { 
    2. 
  
  
  
  2.     LockMethod lockMethod; 
    3. 
  
  
  
  3.     void deal(LockMethod lockMethod){ 
    4. 
  
  
  
  4.         this.lockMethod = lockMethod; 
    5. 
  
  
  
  5.     } 
    6. 
  
  
  
  6.  
    7. 
  
  
  
  7.     @Override 
    8. 
  
  
  
  8.     public void run() { 
    9. 
  
  
  
  9.         super.run(); 
    10. 
  
  
  
  10.         lockMethod.busiB(); 
    11. 
  
  
  
  11.     } 
    12. 
  
  
  
  12. } 
    13.

TestLockMethod类，使用线程BUSSA与BUSSB进行业务处理：

 
 
 
    
  
  
  
  1. public class TestLockMethod extends Thread { 
    2. 
  
  
  
  2.  
    3. 
  
  
  
  3.     public static void main(String[] args) { 
    4. 
  
  
  
  4.         LockMethod lockMethod = new LockMethod(); 
    5. 
  
  
  
  5.         BUSSA bussa = new BUSSA(); 
    6. 
  
  
  
  6.         BUSSB bussb = new BUSSB(); 
    7. 
  
  
  
  7.         bussa.deal(lockMethod); 
    8. 
  
  
  
  8.         bussb.deal(lockMethod); 
    9. 
  
  
  
  9.         bussa.start(); 
    10. 
  
  
  
  10.         bussb.start(); 
    11. 
  
  
  
  11.  
    12. 
  
  
  
  12.     } 
    13. 
  
  
  
  13. } 
    14. 
  
  
  
  14. 运行程 
    15.

运行程序，可以看到在线程bussa 执行的过程中，bussb是不能够进入函数 busiB()的，因为此时lockMethod 的对象锁被线程bussa获取了。

二、缩小同步代码块，只锁数据

有时候为了编程方便，有些人会synchnoized很大的一块代码，如果这个代码块中的某些操作与共享资源并不相关，那么应当把它们放到同步块外部，避免长时间的持有锁，造成其他线程一直处于等待状态。尤其是一些循环操作、同步I/O操作。

不止是在代码的行数范围上缩小同步块，在执行逻辑上，也应该缩小同步块，例如多加一些条件判断，符合条件的再进行同步，而不是同步之后再进行条件判断，尽量减少不必要的进入同步块的逻辑。

三、锁中尽量不要再包含锁

这种情况经常发生，线程在得到了A锁之后，在同步方法块中调用了另外对象的同步方法，获得了第二个锁，这样可能导致一个调用堆栈中有多把锁的请求，多线程情况下可能会出现很复杂、难以分析的异常情况，导致死锁的发生。下面的代码显示了这种情况：

 
 
 
    
  
  
  
  1. synchronized(A){  
    2. 
  
  
  
  2.    synchronized(B){  
    3. 
  
  
  
  3.       }   } 
    4.

或是在同步块中调用了同步方法：

 
 
 
    
  
  
  
  1. synchronized(A){  
    2. 
  
  
  
  2.     B  b = objArrayList.get(0); 
    3. 
  
  
  
  3.     b.method(); //这是一个同步方法 
    4. 
  
  
  
  4. } 
    5.

解决的办法是跳出来加锁，不要包含加锁：

 
 
 
    
  
  
  
  1. { 
    2. 
  
  
  
  2.      B b = null; 
    3. 
  
  
  
  3.  
    4. 
  
  
  
  4.  synchronized(A){ 
    5. 
  
  
  
  5.     b = objArrayList.get(0); 
    6. 
  
  
  
  6.   } 
    7. 
  
  
  
  7.   b.method(); 
    8. 
  
  
  
  8. } 
    9.

四、将锁私有化，在内部管理锁

把锁作为一个私有的对象，外部不能拿到这个对象，更安全一些。对象可能被其他线程直接进行加锁操作，此时线程便持有了该对象的对象锁，例如下面这种情况：

 
 
 
    
  
  
  
  1. class A { 
    2. 
  
  
  
  2.     public void method1() { 
    3. 
  
  
  
  3.     } 
    4. 
  
  
  
  4. } 
    5. 
  
  
  
  5.  
    6. 
  
  
  
  6. class B { 
    7. 
  
  
  
  7.     public void method1() { 
    8. 
  
  
  
  8.         A a = new A(); 
    9. 
  
  
  
  9.         synchronized (a) { //直接进行加锁 
    10. 
  
  
  
  10. 　　　　　　a.method1(); 
    11. 
  
  
  
  11.  
    12. 
  
  
  
  12.         } 
    13. 
  
  
  
  13.     } 
    14. 
  
  
  
  14. } 
    15.

这种使用方式下，对象a的对象锁被外部所持有，让这把锁在外部多个地方被使用是比较危险的，对代码的逻辑流程阅读也造成困扰。一种更好的方式是在类的内部自己管理锁，外部需要同步方案时，也是通过接口方式来提供同步操作：

 
 
 
    
  
  
  
  1. class A { 
    2. 
  
  
  
  2.     private Object lock = new Object(); 
    3. 
  
  
  
  3.     public void method1() { 
    4. 
  
  
  
  4.         synchronized (lock){ 
    5. 
  
  
  
  5.  
    6. 
  
  
  
  6.         } 
    7. 
  
  
  
  7.     } 
    8. 
  
  
  
  8. } 
    9. 
  
  
  
  9.  
    10. 
  
  
  
  10. class B { 
    11. 
  
  
  
  11.     public void method1() { 
    12. 
  
  
  
  12.         A a = new A(); 
    13. 
  
  
  
  13.         a.method1(); 
    14. 
  
  
  
  14.     } 
    15. 
  
  
  
  15. } 
    16.

五、进行适当的锁分解

考虑下面这段程序：

 
 
 
    
  
  
  
  1. public class GameServer { 
    2. 
  
  
  
  2.   public Map> tables = new HashMap>(); 
    3. 
  
  
  
  3.  
    4. 
  
  
  
  4.   public void join(Player player, Table table) { 
    5. 
  
  
  
  5.     if (player.getAccountBalance() > table.getLimit()) { 
    6. 
  
  
  
  6.       synchronized (tables) { 
    7. 
  
  
  
  7.         List tablePlayers = tables.get(table.getId()); 
    8. 
  
  
  
  8.         if (tablePlayers.size() < 9) { 
    9. 
  
  
  
  9.           tablePlayers.add(player); 
    10. 
  
  
  
  10.         } 
    11. 
  
  
  
  11.       } 
    12. 
  
  
  
  12.     } 
    13. 
  
  
  
  13.   } 
    14. 
  
  
  
  14.   public void leave(Player player, Table table) {/*省略*/}  
    15. 
  
  
  
  15.   public void createTable() {/*省略*/}  
    16. 
  
  
  
  16.   public void destroyTable(Table table) {/*省略*/} 
    17. 
  
  
  
  17. } 
    18.

在这个例子中，join方法只使用一个同步锁，来获取tables中的List对象，然后判断玩家数量是不是小于9，如果是，就调增加一个玩家。当有成千上万个List存在tables中时，对tables锁的竞争将非常激烈。

在这里，我们可以考虑进行锁的分解：快速取出数据之后，对List对象进行加锁，让其他线程可快速竞争获得tables对象锁：

 
 
 
    
  
  
  
  1. public class GameServer { 
    2. 
  
  
  
  2.   public Map> tables = new HashMap>(); 
    3. 
  
  
  
  3.  
    4. 
  
  
  
  4.   public void join(Player player, Table table) { 
    5. 
  
  
  
  5.     if (player.getAccountBalance() > table.getLimit()) { 
    6. 
  
  
  
  6.       List tablePlayers = null; 
    7. 
  
  
  
  7.       synchronized (tables) { 
    8. 
  
  
  
  8.           tablePlayers = tables.get(table.getId()); 
    9. 
  
  
  
  9.       } 
    10. 
  
  
  
  10.  
    11. 
  
  
  
  11.       synchronized (tablePlayers) { 
    12. 
  
  
  
  12.         if (tablePlayers.size() < 9) { 
    13. 
  
  
  
  13.           tablePlayers.add(player); 
    14. 
  
  
  
  14.         } 
    15. 
  
  
  
  15.       } 
    16. 
  
  
  
  16.     } 
    17. 
  
  
  
  17.   } 
    18. 
  
  
  
  18.  
    19. 
  
  
  
  19.  public void leave(Player player, Table table) {/*省略*/}  
    20. 
  
  
  
  20.  public void createTable() {/*省略*/}  
    21. 
  
  
  
  21.  public void destroyTable(Table table) {/*省略*/} 
    22. 
  
  
  
  22. } 
    23.

网页名称：Java多线程编程—锁优化
链接分享：http://www.mswzjz.com/qtweb/news18/195568.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

网站策划知识

行业网站建设

新网创想　　 　成都做网站　　 　资阳服务器托管　　 　南宁旺客科技　　 　成都做网站　　 　江安网站建设　　 　H5网站制作　　 　网站建设策划方案　　 　犀浦防护栏定制　　 　成都免费自助建站　　 　主机托管　　 　网页改版　　 　达州网站建设　　 　外贸营销网站建设　　 　成都企业网站设计　　 　app开发　　 　网站seo优化　　 　成都网站推广　　 　公司网站建设　　 　造型师设计