java如何使用线程锁的_Java线程知识：二、锁的简单使用

锁的初步认识

说到锁，相信大家都不陌生，这是我们生活中非常常见的一种东西，它的形状也各式各样。在生活中，我们通常用锁来锁住房子的大门、装宠物的笼子、装衣服的衣柜、以及装着我们一些小秘密的小抽屉......

那么相同的，Java中的锁也各式各样，我们往往按照是否含有某一特性来定义锁，并将锁进行归、分组，具体可分为以下几种：

而这些锁在Java中的具体实现都离不开synchronized 关键字和java.util.concurrent.locks.Lock接口类，本篇随笔就以synchronized关键字和Lock接口的实现类ReentrantLock来展示对锁的简单使用。

synchronized 内置锁(隐式锁)

作为Java中53个关键字的其中之一，synchronized占有举重若轻的地位，它是Java语言本身为我们提供的一种同步锁，所以又被称为内置锁或 隐式锁。

1、从语法维度上来讲，synchronized一共有三种用法：

静态方法上加关键字

public static synchronized void add(){}

实例方法上加关键字

public synchronized void add(){}

方法中使用同步代码块

public void add(){

synchronized(this){}

}

在讲解这些用法之前，我们先来看一段代码：

/**

* @author cai

*/

public class SynDemo {

private static int num = 0;

private static final int ADD_NUM = 2000;

private static final int THREAD_NUM = 5;

private static class UserThread extends Thread {

private SynDemo synDemo;

public UserThread(String threadName, SynDemo synDemo) {

super(threadName);

this.synDemo = synDemo;

}

@Override

public void run() {

synDemo.add();

}

}

public void add() {

for (int i = 0; i < ADD_NUM; i++) {

num++;

}

System.out.println(Thread.currentThread().getName()

+ " 运行完之后的结果为：" + num);

}

public static void main(String[] args) {

// 开启5个线程，使num累计计数到10000

SynDemo synDemo = new SynDemo();

for (int i = 0; i < THREAD_NUM; i++) {

UserThread userThread = new UserThread("thread_" + i, synDemo);

userThread.start();

}

}

}

如代码中一般，我们开启5个线程，并循环使num变量累计计数，同时打印每个线程运行完之后，num变量的数值，那么我们所期待的结果一定是这样的：

然而这是在没有考虑并发的情况下的理想结果，但现实却是：在线程thread_0还没从循环中脱离时，线程thread_1已经进入了循环，从而导致了num变量的多次计数，所以就变成了以下结果(运行结果不止这一种，我只是选取了随机的一种，以下代码的运行结果都是这样。)：

那么我们用上synchronized关键字，再来看看运行结果：

1.1 实例方法上加关键字

/**

* 在实例方法 (普通方法) 上加关键字

*/

public synchronized void add() {

for (int i = 0; i < ADD_NUM; i++) {

num++;

}

System.out.println(Thread.currentThread().getName() + " 运行完之后的结果为：" + num);

}

这时的运行结果就变成了这样：

这里的线程顺序问题不用纠结，因为synchronized是一种非公平锁，线程不会按顺序去排队，而是争先恐后的去抢这唯一的一把锁，所以每次的运行结果中的线程顺序大多不相同，但num变量的计数结果确实与我们所期望的结果相符合的。

1.2 静态方法上加关键字

/**

* 在静态方法上加关键字

*/

public static synchronized void add() {

for (int i = 0; i < ADD_NUM; i++) {

num++;

}

System.out.println(Thread.currentThread().getName() + " 运行完之后的结果为：" + num);

}

结果：

1.3 方法中使用同步代码块

public void add() {

synchronized (this){

for (int i = 0; i < ADD_NUM; i++) {

num++;

}

System.out.println(Thread.currentThread().getName() + " 运行完之后的结果为：" + num);

}

}

结果：

从结果上来看，以上三种的加锁方式都能满足我们的需求，使num变量计数到10000，但不论在我们日常使用上，还是从Java语言本身的建议上讲，更推荐使用第三种用法，即在方法中使用同步代码块的用法，这种方法的性能要比前面两种更好一些，至于为什么，就是属于JVM层次的研究了，这里不多赘述。

再回到我们的第三种用法，其实它不止这一种写法，我们可以按上述的代码样式书写：synchronized(this){}，也可以这样写：synchronized(SynDemo.class){}，还有private SynDemo synDemo = new SynDemo(); synchronized(synDemo){}这样的写法。看到这里，肯定有很多人的心里不禁的浮现出三个大字：WTF ? ? ?，这都是些什么玩意！！！！synchronized到底锁住的是谁！？？？

那么我们就来从另一个维度来揭露一下。

2、从synchronized锁的是谁的维度来讲，一共有两种情况：

2.1 对象锁

我们这里先保留上面 1.3 中的代码不变，稍稍变动一下main方法中的代码：

如上图所示，将创建synDemo对象的代码从for循环外移入for循环内，这样的话，我们每次新建线程时所传入的synDemo对象是不同的，这时候再来看看运行的结果：

这样的结果又和我们的期望大相径庭，那么我们是不是可以认定synchronized(this){}锁住的就是对象呢？让我们再来看一个实例：

/**

* @author cai

*/

public class SynDemo {

private static int num = 0;

private static final int ADD_NUM = 2000;

private static final int THREAD_NUM = 5;

// 共享的对象

private static SynDemo synDemo = new SynDemo();

private static class UserThread extends Thread {

/*public UserThread(String threadName, SynDemo synDemo) {

super(threadName);

this.synDemo = synDemo;

}*/

public UserThread(String threadName){

super(threadName);

}

@Override

public void run() {

synDemo.add();

}

}

public void add() {

synchronized (synDemo){

for (int i = 0; i < ADD_NUM; i++) {

num++;

}

System.out.println(Thread.currentThread().getName()

+ " 运行完之后的结果为：" + num);

}

}

public static void main(String[] args) {

// 开启5个线程，使num累计计数到10000

// SynDemo synDemo = new SynDemo();

for (int i = 0; i < THREAD_NUM; i++) {

// SynDemo synDemo = new SynDemo();

UserThread userThread = new UserThread("thread_" + i);

userThread.start();

}

}

}

如图，我们将UserThread类的构造器做一下改变，并将SynDemo对象共享出来，同时换上第三种写法：private SynDemo synDemo = new SynDemo(); synchronized(synDemo){}，这时的结果为：

从结果我们可以推断出synchronized(this){}、private SynDemo synDemo = new SynDemo(); synchronized(synDemo){}这两种写法中synchronized锁住的是类的对象：在类的对象相同的情况下，多个线程访问一段加锁( 对象锁 )的代码时，只有一个线程能拿到锁。

2.2 类锁

我们来回到2.1中的最初代码，将synchronized (this) {}改为synchronized (SynDemo.class){}：

public void add() {

// synchronized (this) {

synchronized (SynDemo.class){

for (int i = 0; i < ADD_NUM; i++) {

num++;

}

System.out.println(Thread.currentThread().getName()

+ " 运行完之后的结果为：" + num);

}

}

public static void main(String[] args) {

// 开启5个线程，使num累计计数到10000

// SynDemo synDemo = new SynDemo();

for (int i = 0; i < THREAD_NUM; i++) {

SynDemo synDemo = new SynDemo();

UserThread userThread = new UserThread("thread_" + i, synDemo);

userThread.start();

}

}

结果：

由此可见，synchronized (SynDemo.class){}是对SynDemo整个类进行加锁，所以即便每个线程传入的synDemo对象不同，但在运行加锁代码块时，都要去抢夺锁，所以num变量每次打印的计数值都是符合我们心里的预期的。

讲到这里，肯定会有人好奇：synchronized另外两种用法锁住的是对象还是类呢？让我们修改一下代码看看：

public synchronized void add() {

// synchronized (this) {

// synchronized (SynDemo.class){

for (int i = 0; i < ADD_NUM; i++) {

num++;

}

System.out.println(Thread.currentThread().getName()

+ " 运行完之后的结果为：" + num);

// }

}

public static void main(String[] args) {

// 开启5个线程，使num累计计数到10000

// SynDemo synDemo = new SynDemo();

for (int i = 0; i < THREAD_NUM; i++) {

SynDemo synDemo = new SynDemo();

UserThread userThread = new UserThread("thread_" + i, synDemo);

userThread.start();

}

}

结果：

public static synchronized void add() {

// synchronized (this) {

// synchronized (SynDemo.class){

for (int i = 0; i < ADD_NUM; i++) {

num++;

}

System.out.println(Thread.currentThread().getName()

+ " 运行完之后的结果为：" + num);

// }

}

结果：

结论

由上面的各种代码的运行结果，我们可以得出以下结论

public synchronized void add(){}、synchronized(this){}、private SynDemo synDemo = new SynDemo(); synchronized(synDemo){}这三种写法中的synchronized锁住的都是对象，即对象锁

public static synchronized void add(){}、synchronized(SynDemo.class){}这两种写法中的synchonized锁住的都是类，即类锁

建议： 在日常工作或学习中，使用代码块加锁的方式。

Lock 显示锁

与synchronized不同，Lock是JDK1.5为我们提供的一个api，所以它与synchronized一明一暗，被称为显示锁。

Lock作为一个接口，有着多个实现类：ReadLock、ReentrantLock、WriteLock ......

而我们今天的主角便是：ReentrantLock，先来看看如何使用：

private static Lock lock = new ReentrantLock();

public void add() {

// 拿到锁

lock.lock();

try {

for (int i = 0; i < ADD_NUM; i++) {

num++;

}

System.out.println(Thread.currentThread().getName()

+ " 运行完之后的结果为：" + num);

} finally {

// 释放锁

lock.unlock();

}

}

与synchronized不同，lock并没有类锁和对象锁的分类，它的用法也是非常的简单，lock()方法是当前线程拿到锁，unlock()方法是当前线程释放锁。是的，lock与synchronized最大的不同就是lock需要线程自己去释放锁，而synchronized是JVM帮我们释放锁。如果当前拿到锁的线程不及时的调用unlock()方法时，程序将不会终止，所有的线程都会卡在方法外。

我们先来看看上面代码的运行结果：

我们再将unlock()方法注释掉看看：

private static Lock lock = new ReentrantLock();

public void add() {

// 拿到锁

lock.lock();

try {

for (int i = 0; i < ADD_NUM; i++) {

num++;

}

System.out.println(Thread.currentThread().getName()

+ " 运行完之后的结果为：" + num);

} finally {

// 释放锁

// lock.unlock();

}

}

结果：

正如上面所说的那般，程序不会终止，仅有一个线程打印了结果。

结论

使用lock锁时，必须在try{}代码块之前调用lock()方法，并在finally{}代码块中调用unlock()方法及时的释放锁。

最后

synchronized与Lock不论在本质还是用法上面都有很多的不同，不是一两句就能讲清楚的，在以后的随笔中，我会逐步的去分享Lock中的各种方法，会将sychronized和Lock的不同做个最后的总结，这也是非常重要的一个知识点。