（三）线程------Java锁机制

最新推荐文章于 2021-02-13 03:29:57 发布

lzy_tinyjoy

最新推荐文章于 2021-02-13 03:29:57 发布

阅读量847

点赞数

分类专栏： JAVA

本文链接：https://blog.csdn.net/u012810020/article/details/60871141

版权

JAVA 专栏收录该内容

17 篇文章 1 订阅

订阅专栏

简述：

上两节中我们讲述的都是一些理论知识，感觉很枯燥但是又不得不说，从这篇博文开始突然有种“初极狭，才通人。复行数十步，豁然开朗”的感觉。理论指导实践开始吧！开始锁机制之前一定要清楚两件事情：1.锁的对象是谁，2.谁持有了锁。

锁的种类：

我们先来看一下synchronized锁的种类：

1、对象锁：带有synchronized的同步方法或者带有synchronized（this）的同步代码块。

public synchronized void getXXX(){

}

或者

public void getXXX(){
    synchronized(){

    }
}

2、类锁：带有synchronized的static方法或者带有synchronized(xxx.class)、synchronized(this.getClass())的静态代码块。如下实例：

public static synchronized void getXXX(){

}

或者

public void getXXX(){
    synchronized(Main.class){

    }
}

public void getXXX(){
    synchronized(this.getClass()){

    }
}

3、私有锁：在类中声明属性private final Object mMutex = new Object();并在方法中使用synchronized(mMutex);

锁的使用：

1、对象锁：

对象锁代码如下：

package com.lzy.test.suo;

public class ObjectLock {
     public void print() {
          synchronized (this) {
              for(int i=0;i<1000;i++){
                   System.out.println("锁持有者线程ID:" + Thread.currentThread().getId());
                   System.out.println("锁的对象为：" + this.getClass().hashCode());
              }
          }
     }
}

测试代码：

public class SuoTest {
     public static void main(String[] args) {

          new Thread(new  Runnable() {
              public void run() {
                   ObjectLock objectLock1 = new ObjectLock();
                   objectLock1.print();
                   try {
                        Thread.sleep(1000);
                   } catch (InterruptedException e) {
                        e.printStackTrace();
                   }
              }
          }).start();


          new Thread(new Runnable() {

              @Override
              public void run() {
                   ObjectLock objectLock2 = new ObjectLock();
                   objectLock2.print();
                   try {
                        Thread.sleep(1000);
                   } catch (InterruptedException e) {
                        e.printStackTrace();
                   }
              }
          }).start();

     }
}

运行后截取部分日志如下：

锁持有者线程ID:11
锁持有者线程ID:10
锁的对象为：166939988
锁持有者线程ID:10
锁的对象为：166939988

从日志中可以看出：线程并没有同步而是交叉执行。为什么会出现不同步的现象呢？上面说过，锁机制我们应该清楚两件事情：1.锁的对象是谁，2.谁持有了锁。现在分析一下，线程ID为10的线程持有一把锁，这把锁对象为objectLock1,而线程ID为11的线程也持有一把锁，锁的对象为objectLock2。到这里我们就突然明白了，两个线程持有的不是同一把锁，因此也不存在锁的竞争关系，所以也就没有得到线程同步结果。那如何改进呢？我们改进的方法有两种，为了让锁唯一，我们可以将ObjectLock类使用单例模式，这样就能确保锁唯一啦，另外我们不采用单例，我们可以将ObjectLock实例置于外部类中，这样其实例将会保存在堆中，而其引用保存在栈中，这样就可以每次使用同一个对象的引用就OK啦，但是这样存在一个非常复杂的问题：每次都要就行对象引用的参数传递，非常地麻烦，因此建议使用单利模式。

注意：直接使用对象锁的时候最好是在单例模式中使用。

2、私有锁的使用

对象锁存在的问题就是得使用单例，如果说这个操作的对象正好是单例（如数据库操作）倒没什么，如果说明显不能使用单例的话，显然上述锁存在明显的限制性。私有锁可以解决这个问题，其实私有锁也属于对象锁的一种。

我们对仅仅对ObjectLock进行如下改动：

public class ObjectLock {
     private Object mMutex = new Object();

     public void print() {
          synchronized (mMutex) {
              for (int i = 0; i < 1000; i++) {
                   System.out.println("锁持有者线程ID:" + Thread.currentThread().getId());
                   System.out.println("锁的对象为：" + mMutex.hashCode());
              }
          }
     }
}

运行后的部分日志如下：

锁持有者线程ID:10
锁的对象为：1652365127
锁持有者线程ID:11
锁持有者线程ID:10
锁的对象为：1652365127
锁持有者线程ID:10
锁的对象为：1652365127
锁持有者线程ID:10
锁的对象为：1652365127
锁的对象为：1799665936
锁持有者线程ID:11
锁的对象为：1799665936

咦！怎么跟想象的不太一样呢？对的，我们分析一下日志：线程ID为10的线程持有一把私有锁，私有锁的对象为objectLock1.mMutex，线程ID为11的线程持有一把私有锁，私有锁的对象为objectLock2.mMutex。OK，他们两个线程压根就没有持有同一把锁对象，所以也就不存在竞争关系。可能有人问那你刚才不是已经说私有锁能够解决上面的问题吗？现在也没有解决呀，各位吃瓜群众稍安勿躁，他们现在的问题是没有持有同一把锁，我给私有锁加上两个关键字再看一下结果会不会一样：

public class ObjectLock {
     private static final Object mMutex = new Object();

     public void print() {
          synchronized (mMutex) {
              for (int i = 0; i < 1000; i++) {
                   System.out.println("锁持有者线程ID:" + Thread.currentThread().getId());
                   System.out.println("锁的对象为：" + mMutex.hashCode());
              }
          }
     }
}

运行一下果然解决了这个问题。在实际开发中我们经常会用到的私有锁的形式也是上面的形式。所以要谨记：在使用私有锁的时候一定要在私有锁对象上加上静态关键字static或者直接加上static和final两个关键字让其变为一个常量。

3、类锁的使用

类锁的使用就比较简单了，因为每个线程都会持有同一把锁对象，而其锁的对象为唯一且为Class对象，所以类锁一定存在竞争的关系，同步方法也一定会同步的。

public class ClassLock {
     public void print() {
          synchronized (ClassLock.class) {
              System.out.println("锁持有者线程:" + Thread.currentThread().getName());
              System.out.println("锁对象为：" + "ClassLock.class");
          }
     }
}