我眼中多线程的锁

做了快6年的java项目了，仅用过一次多线程，而且都是架构组封装好的，仅需要调用即可，现在想起来，真是惭愧....近期在项目中又遇到一个需要用多线程处理的问题，因此仔细研究了一下...

------------------------------------------------------------------------------------------------------------------------------------

首先，了解什么是锁，举个简单的例子，你出门的时候会把门锁上，这叫给门这个对象上锁，然后回到家过后肯定会打开锁推门进屋，这叫给门这个对象解锁。在给对象上锁后，若不解锁，则其他人就无法使用这个对象，(假若你带一个朋友回家，假若你不开锁，朋友就无法推开门，推开门就是你朋友在使用你们家门这个对象），在这儿假若你和你朋友是二个线程，你朋友在等你开门的过程中，就是在线程等待，你是正在执行的线程，若你发现钥匙丢了开不了门，就会造成你朋友等待，造成线程执行超时（本来平时开门就两分钟时间），假若你一直都解决不了开锁的问题，你朋友就会一直等待，从而造成死锁...

在java里面的锁，有两类锁，类锁和对象锁。

一、首先我们来说说类锁

实现类锁有两种方式：在方法前加static synchronized或在方法体内对部分或所有代码加synchronized(XXX.class)。

注意：我们要知道，一个类只有一个类锁，当某个线程A为了执行该类的某个已被标识为需要获得类锁才能执行的方法时，若该类的类锁正在被其它线程占用，则线程A会一直等待，直到被其它线程占用的类锁被释放。

对于类锁，方法的执行顺序，主要有四点：

第一，当几个线程同时访问某个类的不同方法时，若执行这些方法都需要获得该类的类锁时，则这几个线程串行执行。举个例子，有个ClassLock类，里面有a()和b()两个方法，执行这两个方法都需要获得该类的类锁（因为方法被标记了static synchronized），此时有两个线程，分别访问a()和b()方法，则这两个线程串行执行，代码示例如下：

public class ClassLock {
public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {
a();
}
}, "线程一").start();
new Thread(new Runnable() {
@Override
public void run() {
b();
}
}, "线程二").start();
}

public static synchronized void a() {
System.out.println("线程" + Thread.currentThread().getName() + "正在执行");
System.out.println("线程" + Thread.currentThread().getName()
+ "正在执行，a();获得类锁，时间：" + new Date().toLocaleString());
System.out.println("线程" + Thread.currentThread().getName()
+ "正在执行，a();正在处理数据，时间" + new Date().toLocaleString());
try {
Thread.sleep(5000);
System.out.println("线程" + Thread.currentThread().getName()
+ "正在执行，a();已处理完数据，释放类锁");
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

public static synchronized void b() {
System.out.println("线程" + Thread.currentThread().getName() + "正在执行");
System.out.println("线程" + Thread.currentThread().getName()
+ "正在执行，b();获得类锁，时间：" + new Date().toLocaleString());
System.out.println("线程" + Thread.currentThread().getName()
+ "正在执行，b();正在处理数据，时间" + new Date().toLocaleString());
try {
Thread.sleep(5000);
System.out.println("线程" + Thread.currentThread().getName()
+ "正在执行，b();已处理完数据，释放类锁");
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

控制台输出如下：
---------------------------------------------------------
线程线程一正在执行
线程线程一正在执行，a();获得类锁，时间：2016-1-22 9:20:06
线程线程一正在执行，a();正在处理数据，时间2016-1-22 9:20:06
线程线程一正在执行，a();已处理完数据，释放类锁
线程线程二正在执行
线程线程二正在执行，b();获得类锁，时间：2016-1-22 9:20:11
线程线程二正在执行，b();正在处理数据，时间2016-1-22 9:20:11
线程线程二正在执行，b();已处理完数据，释放类锁

第二，当几个线程同时访问某个类的相同方法时，若执行这个方法需要获得该类的类锁时，则这几个线程串行执行，代码示例如下：

public class ClassLock2 {
public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {
a();
}
}, "线程一").start();
new Thread(new Runnable() {
@Override
public void run() {
a();
}
}, "线程二").start();
}

public static synchronized void a() {
System.out.println("线程" + Thread.currentThread().getName()
+ "正在执行，a();获得类锁，时间：" + new Date().toLocaleString());
System.out.println("线程" + Thread.currentThread().getName()
+ "正在执行，a();正在处理数据，时间" + new Date().toLocaleString());
try {
Thread.sleep(5000);
System.out.println("线程" + Thread.currentThread().getName()
+ "正在执行，a();已处理完数据，释放类锁");
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

控制台输出如下：
---------------------------------------------------------
线程线程一正在执行，a();获得类锁，时间：2016-1-22 9:26:17
线程线程一正在执行，a();正在处理数据，时间2016-1-22 9:26:17
线程线程一正在执行，a();已处理完数据，释放类锁
线程线程二正在执行，a();获得类锁，时间：2016-1-22 9:26:22
线程线程二正在执行，a();正在处理数据，时间2016-1-22 9:26:22
线程线程二正在执行，a();已处理完数据，释放类锁

第三、当几个线程同时访问某个类的不同方法时，若该类中仅其中一个方法在执行时需要获得类锁，则这几个线程并行执行，代码示例如下：

public class ClassLock3 {
public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {
a();
}
}, "线程一").start();
new Thread(new Runnable() {
@Override
public void run() {
b();
}
}, "线程二").start();
}

public static synchronized void a() {
System.out.println("线程" + Thread.currentThread().getName()
+ "正在执行，a();获得类锁，时间：" + new Date().toLocaleString());
System.out.println("线程" + Thread.currentThread().getName()
+ "正在执行，a();正在处理数据，时间" + new Date().toLocaleString());
try {
Thread.sleep(5000);
System.out.println("线程" + Thread.currentThread().getName()
+ "正在执行，a();已处理完数据，释放类锁");
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

public static void b() {
System.out.println("线程" + Thread.currentThread().getName()
+ "正在执行，a();获得类锁，时间：" + new Date().toLocaleString());
System.out.println("线程" + Thread.currentThread().getName()
+ "正在执行，a();正在处理数据，时间" + new Date().toLocaleString());
try {
Thread.sleep(5000);
System.out.println("线程" + Thread.currentThread().getName()
+ "正在执行，a();已处理完数据，释放类锁");
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

控制台输出如下：
---------------------------------------------------------
线程线程一正在执行，a();获得类锁，时间：2016-1-22 9:29:04
线程线程二正在执行，a();获得类锁，时间：2016-1-22 9:29:04
线程线程一正在执行，a();正在处理数据，时间2016-1-22 9:29:04
线程线程二正在执行，a();
4000
正在处理数据，时间2016-1-22 9:29:04
线程线程二正在执行，a();已处理完数据，释放类锁
线程线程一正在执行，a();已处理完数据，释放类锁

第四，当几个线程同时访问某个类的不同方法时，若执行该类的这些方法都不需要获得该类的类锁，则几个线程并行执行，很简单，我这儿就不举例了。

上面例子中我们还可以通过synchronized (ClassLock.class) 这种方式获得类锁，以下这两种方式效果相同

public static synchronized void methodName() {
System.out.println("进入方法");
System.out.println("处理数据");
System.out.println("执行完成");
}
public static void methodName() {
synchronized (XXX.class) {
System.out.println("进入方法");
System.out.println("处理数据");
System.out.println("执行完成");
}
}

synchronized(XXX.class)方式相对灵活一些，它可以针对方法体内的某些代码而不是所有代码(作用范围可以根据需要调整)，若作用范围不是整个方法体，当多个线程同时访问该方法时，不需要获得类锁的代码同步执行，需要获得类锁的代码串行执行，例

public class ClassLock01 {
public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {
a();
}
}, "线程一").start();
new Thread(new Runnable() {
@Override
public void run() {
a();
}
}, "线程二").start();
}

public static void a() {
System.out.println("线程" + Thread.currentThread().getName() + "正在执行，时间"
+ new Date().toLocaleString());
synchronized (ClassLock01.class) {
System.out.println("线程" + Thread.currentThread().getName()
+ "正在执行，a();获得类锁，时间：" + new Date().toLocaleString());
System.out.println("线程" + Thread.currentThread().getName()
+ "正在执行，a();正在处理数据，时间" + new Date().toLocaleString());
try {
Thread.sleep(5000);
System.out.println("线程" + Thread.currentThread().getName()
+ "正在执行，a();已处理完数据，释放类锁");
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}

控制台输出如下：
---------------------------------------------------------
线程线程二正在执行，时间2016-1-22 9:34:52
线程线程一正在执行，时间2016-1-22 9:34:52
线程线程二正在执行，a();获得类锁，时间：2016-1-22 9:34:52
线程线程二正在执行，a();正在处理数据，时间2016-1-22 9:34:52
线程线程二正在执行，a();已处理完数据，释放类锁
线程线程一正在执行，a();获得类锁，时间：2016-1-22 9:34:57
线程线程一正在执行，a();正在处理数据，时间2016-1-22 9:34:57
线程线程一正在执行，a();已处理完数据，释放类锁

关于类锁我们就讲完了，我们总结一下，其实最重要的一点：一个类只有一个类锁，当某个线程A为了执行该类的某个已被标识为需要获得类锁才能执行的方法时，若该类的类锁正在被其它线程占用，则线程A会一直等待，直到被其它线程占用的类锁被释放。
第二，我们来说下对象锁

首先我们要知道：一个对象只有一把锁，如果一个对象被某个标识为synchronized的方法或synchronized(XXX){//}的代码块引用了，而这个方法此时又正在被A线程执行，那么这个对象此时就被锁住了，要等到A线程执行完synchronized作用范围的代码，这个对象的锁才会被释放，才能被其它线程访问。

锁住对象的方式有两种，在方法前上synchronizd或在方法体内标识synchronizd(对象)，在方法前加synchronizd，那这把锁的作用范围是整个方法体，而在方法内部用synchronizd(对象)标识，则作用范围要灵活得多，可以是整个方法体，也可以是部分语句块。在锁的作用范围内的所有对象，都将被锁住，只到当锁被释放后，才能被另外一个线程访问。

我们来举个例子，ObjectLockC类的main方法中有线程一、线程二、线程三，三个线程，在类中有a()方法，调用时需要传入d对象，a()方法中直接会调用d对象的打印方法执行打印操作，d对象打印时需要获得对象d的锁，线程二、线程三调用ObjectLockC类A()方法，代码如下：

public class ObjectLockC {
public static void main(String[] args) {
final ObjectLockC ca = new ObjectLockC();
final D d = new D();
new Thread(new Runnable() {
@Override
public void run() {
ca.a(d);
}
}, "线程一").start();
new Thread(new Runnable() {
@Override
public void run() {
d.print();
}
}, "线程二").start();
new Thread(new Runnable() {
@Override
public void run() {
ca.a(d);
}
}, "线程三").start();
}

public void a(D d) {
System.out.println(Thread.currentThread().getName() + "，正在执行a()方法，时间"
+ new Date().toLocaleString());
synchronized (d) {
d.print();
System.out.println(Thread.currentThread().getName()
+ "正在执行，获得ca对象的锁执行a()方法，时间：" + new Date().toLocaleString());
System.out.println(Thread.currentThread().getName()
+ "正在执行，a();正在处理数据，时间" + new Date().toLocaleString());
try {
Thread.sleep(5000);
System.out.println(Thread.currentThread().getName()
+ "执行结束，a();已处理完数据，释放对象ca和d的锁");
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

static class D {
public synchronized void print() {
System.out.println(Thread.currentThread().getName() + "，正在执行，时间："
+ new Date().toLocaleString());
try {
Thread.sleep(2000);
System.out.println(Thread.currentThread().getName()
+ "，执行结束，时间：" + new Date().toLocaleString());
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}

控制台输出如下：
---------------------------------------------------------
线程二，正在执行，时间：2016-1-22 16:58:51
线程三，正在执行a()方法，时间2016-1-22 16:58:51
线程一，正在执行a()方法，时间2016-1-22 16:58:51
线程二，执行结束，时间：2016-1-22 16:58:53
线程一，正在执行，时间：2016-1-22 16:58:53
线程一，执行结束，时间：2016-1-22 16:58:55
线程一正在执行，获得ca对象的锁执行a()方法，时间：2016-1-22 16:58:55
线程一正在执行，a();正在处理数据，时间2016-1-22 16:58:55
线程一执行结束，a();已处理完数据，释放对象ca和d的锁
线程三，正在执行，时间：2016-1-22 16:59:00
线程三，执行结束，时间：2016-1-22 16:59:02
线程三正在执行，获得ca对象的锁执行a()方法，时间：2016-1-22 16:59:02
线程三正在执行，a();正在处理数据，时间2016-1-22 16:59:02
线程三执行结束，a();已处理完数据，释放对象ca和d的锁

首先，我问一个问题，在上例中，这三个线程是并行执行还是串行执行？在执行线程一时有哪些对象被锁住了？

...知道答案了吗，答案如下：

一、首先线程一、线程二、线程三并行执行，因为线程一、线程三在执行a()方法第一行代码时还没进入到synchronized范围内，因此d对象和ca对象不会被锁，因此三个线程首先并行执行，其次是线程一执行，线程一执行进入a()方法的synchronized的作用范围后，会锁定ca对象，因此线程一、线程三串行执行。

二、在执行线程一时，首先会锁住ca对象，因为a()方法是ca对象的，而a()方法内部又被synchronized标识了，因此当执行到a()方法中synchronized作用范围内的代码时，就会锁住ca对象，为什么要锁住d呢，因d在方法a()中synchronized的作用范围内。

这个就是对象的锁。

上面介绍完了两种锁，我们通过一个例子还看下他们两者的区别，代码如下：

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

test1();
try {
Thread.currentThread().sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
test2();

}

private static void test1() {
final DifLock l1 = new DifLock();
final DifLock l2 = new DifLock();
new Thread(new Runnable() {
@Override
public void run() {
l1.b();
}
}, "线程一").start();
new Thread(new Runnable() {
@Override
public void run() {
l2.b();
}
}, "线程二").start();
}

private static void test2() {
final DifLock l1 = new DifLock();
final DifLock l2 = new DifLock();
new Thread(new Runnable() {
@Override
public void run() {
l1.a();
}
}, "线程一").start();
new Thread(new Runnable() {
@Override
public void run() {
l2.a();
}
}, "线程二").start();
}

public static synchronized void a() {
System.out.println(Thread.currentThread().getName() + "正在执行a()，时间"
+ System.currentTimeMillis() / 1000);
try {
Thread.currentThread().sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

public synchronized void b() {
System.out.println(Thread.currentThread().getName() + "正在执行b()，时间"
+ System.currentTimeMillis() / 1000);
try {
Thread.currentThread().sleep(2000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

控制台输出如下：
---------------------------------------------------------
线程一正在执行b()，时间1453454757
线程二正在执行b()，时间1453454757
线程一正在执行a()，时间1453454762
线程二正在执行a()，时间1453454763

上面的代码中进行了两种测试，第一个测试，两个不同的实例通过两个线程分别调用类锁的方法，执行结果为两个实例串行执行，第二个测试，两个不同实例通过两个线程分别调用对象锁的方法，执行结果为两个实例并行执行，为什么会这样呢？因为第一个测试，DifLock类的类锁只有一个，线程1获得了，那么线程2就需要等待线程1释放类锁，第二个测试，实例1和实例2分别为不同的对象，也就是说对象锁是不一样的，因此线程2不需要等待线程1释放锁。

上面就讲完了，若有问题，请留言。