多线程开发离不开锁机制，现在的Java语言中，提供了2种锁，一种是语言特性提供的内置锁，还有一种是 java.util.concurrent.locks 包中的锁，这篇文章简单整理一下内置锁的知识点。
内置锁在Java语言中的表现：
多线程的锁，其实本质上就是给一块内存空间的访问添加访问权限，因为Java中是没有办法直接对某一块内存进行操作的，又因为Java是面向对象的语言，一切皆对象，所以具体的表现就是某一个对象承担锁的功能，每一个对象都可以是一个锁。内置锁，使用方式就是使用 synchronized 关键字，synchronized 方法或者 synchronized 代码块。
每一种 synchronized 写法的锁是哪个对象：
1、指定当前对象加锁：
private synchronized voidfunction() {//TODO execute something
}
2、指定当前类的Class对象加锁：
private static synchronized voidfunction() {//TODO execute something
}
注意此处的 static 关键字。
3、指定任意对象加锁：
private voidfunction() {synchronized(object) {//TODO execute something
}
}
此时，这段同步代码块的锁加在object对象上面。该对象可以是当前对象(object ==
this)，也可以是当前类的Class对象(object == MyClass.class)。
简单验证一下：
现有如下的类：
public classSynchronizedTest {private Object lock = newObject();public void synchronizedBlockOnObject(longexecuteTime) {synchronized(lock) {
System.out.println(Thread.currentThread().getName()+ " -> start synchronizedBlockOnObject");
doSomething(executeTime);
System.out.println(Thread.currentThread().getName()+ " -> end synchronizedBlockOnObject");
}
}public void synchronizedBlockOnThis(longexecuteTime) {synchronized (this) {
System.out.println(Thread.currentThread().getName()+ " -> start synchronizedBlockOnThis");
doSomething(executeTime);
System.out.println(Thread.currentThread().getName()+ " -> end synchronizedBlockOnThis");
}
}public void synchronizedBlockOnClass(longexecuteTime) {synchronized (SynchronizedTest.class) {
System.out.println(Thread.currentThread().getName()+ " -> start synchronizedBlockOnClass");
doSomething(executeTime);
System.out.println(Thread.currentThread().getName()+ " -> end synchronizedBlockOnClass");
}
}public synchronized void synchronizedMethodOnThis(longexecuteTime) {
System.out.println(Thread.currentThread().getName()+ " -> start synchronizedMethodOnThis");
doSomething(executeTime);
System.out.println(Thread.currentThread().getName()+ " -> end synchronizedMethodOnThis");
}public static synchronized void synchronizedMethodOnClass(longexecuteTime) {
System.out.println(Thread.currentThread().getName()+ " -> start synchronizedMethodOnClass");
doSomething(executeTime);
System.out.println(Thread.currentThread().getName()+ " -> end synchronizedMethodOnClass");
}private static void doSomething(longexecuteTime) {try{
Thread.sleep(executeTime);
}catch(InterruptedException e) {
e.printStackTrace();
}
}
}
1、static synchronized 方法 和 synchronized (MyClass.class) {} 同步代码块的锁都加在
MyClass.class 对象上面：
public static voidmain(String[] args) {
SynchronizedTest synchronizedTest= newSynchronizedTest();new Thread(newRunnable() {
@Overridepublic voidrun() {
SynchronizedTest.synchronizedMethodOnClass(3000);
}
},"Thread static synchronized method").start();new Thread(newRunnable() {
@Overridepublic voidrun() {
synchronizedTest.synchronizedBlockOnClass(2000);
}
},"Thread synchronized block on Class").start();
}
运行结果如下：
Thread static synchronized method ->start synchronizedMethodOnClass
Threadstatic synchronized method ->end synchronizedMethodOnClass
Threadsynchronized block on Class ->start synchronizedBlockOnClass
Threadsynchronized block on Class -> end synchronizedBlockOnClass
说明当线程 Thread static synchronized method 进入方法 synchronizedMethodOnClass
的时候，线程Thread synchronized block on Class 是不能进入synchronizedBlockOnClass 代码块的。
2、非 static 的 synchronized 方法和 synchronized (this) {} 同步代码块的锁都加在当前对象上面：
public static voidmain(String[] args) {
SynchronizedTest synchronizedTest= newSynchronizedTest();new Thread(newRunnable() {
@Overridepublic voidrun() {
synchronizedTest.synchronizedMethodOnThis(3000);
}
},"Thread non-static synchronized method").start();new Thread(newRunnable() {
@Overridepublic voidrun() {
synchronizedTest.synchronizedBlockOnThis(2000);
}
},"Thread synchronized block on this").start();
}
运行结果如下：
Thread non-static synchronized method ->start synchronizedMethodOnThis
Thread non-static synchronized method ->end synchronizedMethodOnThis
Threadsynchronized block on this ->start synchronizedBlockOnThis
Threadsynchronized block on this -> end synchronizedBlockOnThis
说明当线程 Thread non-static synchronized method 进入方法 synchronizedMethodOnThis
的时候，线程Thread synchronized block on this 是不能进入synchronizedBlockOnThis 代码块的。
3、当锁加在 MyClass.class 、 this 、 任意对象，这三种情况，起不到任何同步作用：
public static voidmain(String[] args) {
SynchronizedTest synchronizedTest= newSynchronizedTest();new Thread(newRunnable() {
@Overridepublic voidrun() {
synchronizedTest.synchronizedMethodOnThis(3000);
}
},"Thread non-static synchronized method").start();new Thread(newRunnable() {
@Overridepublic voidrun() {
SynchronizedTest.synchronizedMethodOnClass(2000);
}
},"Thread static sybchronized method").start();new Thread(newRunnable() {
@Overridepublic voidrun() {
synchronizedTest.synchronizedBlockOnObject(4000);
}
},"Thread sybchronized block on other Object").start();
}
运行结果如下：
Thread non-static synchronized method ->start synchronizedMethodOnThis
Threadstatic sybchronized method ->start synchronizedMethodOnClass
Thread sybchronized block on other Object->start synchronizedBlockOnObject
Threadstatic sybchronized method ->end synchronizedMethodOnClass
Thread non-static synchronized method ->end synchronizedMethodOnThis
Thread sybchronized block on other Object-> end synchronizedBlockOnObject
说明当锁没有加在同一个对象上的时候，起不到线程间的同步作用。
Object中对内置锁进行操作的一些方法：
wait()系列：
wait()系列方法的作用是：使当前已经获得该对象锁的线程进入等待状态，并且释放该对象的锁。
notify()系列：
notify()系列方法的作用是：唤醒那些正在等待该对象锁的线程，使其继续运行。
基于wait() notify()机制，我们可以实现一个简易的生产者-消费者模型。
大体思路如下，一个生产者线程负责向一个仓库中存放(put)物品，一个消费者线程负责从仓库中取出(get)物品。
代码如下：
public classWarehouse {private Queuequeue;private intcapacity;public Warehouse(intcapacity) {this.capacity =capacity;
queue= newLinkedList();
}public synchronized void put(intnum) {if (queue.size() >=capacity) {try{
System.out.println(Thread.currentThread().getName()+ " , put full wait");
wait();
}catch(InterruptedException e) {
e.printStackTrace();
}
}
queue.add(num);
System.out.println(Thread.currentThread().getName()+ " , put : " + num + " , queue -> " +queue);
notifyAll();
}public synchronized intget() {if(queue.isEmpty()) {try{
System.out.println(Thread.currentThread().getName()+ " , get empty wait");
wait();
}catch(InterruptedException e) {
e.printStackTrace();
}
}int num =queue.poll();
System.out.println(Thread.currentThread().getName()+ " , get : " + num + " , queue -> " +queue);
notifyAll();returnnum;
}
}
public static voidmain(String[] args) {
Warehouse warehouse= new Warehouse(4);
Random random= newRandom();new Thread(newRunnable() {
@Overridepublic voidrun() {while (true) {
warehouse.put(random.nextInt(10));try{
Thread.sleep(1000);
}catch(InterruptedException e) {
e.printStackTrace();
}
}
}
},"生产者-01").start();new Thread(newRunnable() {
@Overridepublic voidrun() {while (true) {
warehouse.get();try{
Thread.sleep(2000);
}catch(InterruptedException e) {
e.printStackTrace();
}
}
}
},"消费者-01").start();
}
运行结果如下：
生产者-01 , put : 5 , queue -> [5]
消费者-01 , get : 5 , queue ->[]
生产者-01 , put : 7 , queue -> [7]
消费者-01 , get : 7 , queue ->[]
生产者-01 , put : 9 , queue -> [9]
生产者-01 , put : 7 , queue -> [9, 7]
消费者-01 , get : 9 , queue -> [7]
生产者-01 , put : 0 , queue -> [7, 0]
生产者-01 , put : 5 , queue -> [7, 0, 5]
消费者-01 , get : 7 , queue -> [0, 5]
生产者-01 , put : 9 , queue -> [0, 5, 9]
生产者-01 , put : 6 , queue -> [0, 5, 9, 6]
消费者-01 , get : 0 , queue -> [5, 9, 6]
生产者-01 , put : 4 , queue -> [5, 9, 6, 4]
生产者-01, put full wait
消费者-01 , get : 5 , queue -> [9, 6, 4]
生产者-01 , put : 6 , queue -> [9, 6, 4, 6]
生产者-01, put full wait
消费者-01 , get : 9 , queue -> [6, 4, 6]
生产者-01 , put : 2 , queue -> [6, 4, 6, 2]
生产者-01, put full wait
消费者-01 , get : 6 , queue -> [4, 6, 2]
生产者-01 , put : 9 , queue -> [4, 6, 2, 9]
生产者-01, put full wait
消费者-01 , get : 4 , queue -> [6, 2, 9]
生产者-01 , put : 7 , queue -> [6, 2, 9, 7]
生产者-01, put full wait
消费者-01 , get : 6 , queue -> [2, 9, 7]
生产者-01 , put : 2 , queue -> [2, 9, 7, 2]
527
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
