简述：
上两节中我们讲述的都是一些理论知识，感觉很枯燥但是又不得不说，从这篇博文开始突然有种“初极狭，才通人。复行数十步，豁然开朗”的感觉。理论指导实践开始吧！开始锁机制之前一定要清楚两件事情：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");
}
}
}
转载请注明原文地址: https://ju.6miu.com/read-1890.html
