Java:使用synchronized和Lock对象获取对象锁

在并发环境下，解决共享资源冲突问题时，可以考虑使用锁机制。

1.对象的锁

所有对象都自动含有单一的锁。

JVM负责跟踪对象被加锁的次数。如果一个对象被解锁，其计数变为0。在任务（线程）第一次给对象加锁的时候，计数变为1。每当这个相同的任务（线程）在此对象上获得锁时，计数会递增。

只有首先获得锁的任务（线程）才能继续获取该对象上的多个锁。

每当任务离开一个synchronized方法，计数递减，当计数为0的时候，锁被完全释放，此时别的任务就可以使用此资源。

2.synchronized同步块

2.1同步到单一对象锁

当使用同步块时，如果方法下的同步块都同步到一个对象上的锁，则所有的任务（线程）只能互斥的进入这些同步块。

Resource1.java演示了三个线程（包括main线程）试图进入某个类的三个不同的方法的同步块中，虽然这些同步块处在不同的方法中，但由于是同步到同一个对象（当前对象 synchronized (this)），所以对它们的方法依然是互斥的。

Resource1.java

package com.zj.lock;

import java.util.concurrent.TimeUnit;

public class Resource1 {

public void f() {

// other operations should not be locked...

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

+ ":not synchronized in f()");

synchronized (this) {

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

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

+ ":synchronized in f()");

try {

TimeUnit.SECONDS.sleep(3);

} catch (InterruptedException e) {

e.printStackTrace();

}

public void g() {

// other operations should not be locked...

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

+ ":not synchronized in g()");

synchronized (this) {

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

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

+ ":synchronized in g()");

try {

TimeUnit.SECONDS.sleep(3);

} catch (InterruptedException e) {

e.printStackTrace();

}

public void h() {

// other operations should not be locked...

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

+ ":not synchronized in h()");

synchronized (this) {

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

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

+ ":synchronized in h()");

try {

TimeUnit.SECONDS.sleep(3);

} catch (InterruptedException e) {

e.printStackTrace();

}

public static void main(String[] args) {

final Resource1 rs = new Resource1();

new Thread() {

public void run() {

rs.f();

}

}.start();

new Thread() {

public void run() {

rs.g();

}

}.start();

rs.h();

}

结果：

Thread-0:not synchronized in f()

Thread-0:synchronized in f()

main:not synchronized in h()

Thread-1:not synchronized in g()

Thread-0:synchronized in f()

Thread-1:synchronized in g()

main:synchronized in h()

2.2 同步到多个对象锁

Resource1.java演示了三个线程（包括main线程）试图进入某个类的三个不同的方法的同步块中，这些同步块处在不同的方法中，并且是同步到三个不同的对象（synchronized (this)，synchronized(syncObject1)，synchronized (syncObject2)），所以对它们的方法中的临界资源访问是独立的。

Resource2.java

package com.zj.lock;

import java.util.concurrent.TimeUnit;

public class Resource2 {

private Object syncObject1 = new Object();

private Object syncObject2 = new Object();

public void f() {

// other operations should not be locked...

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

+ ":not synchronized in f()");

synchronized (this) {

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

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

+ ":synchronized in f()");

try {

TimeUnit.SECONDS.sleep(3);

} catch (InterruptedException e) {

e.printStackTrace();

}

public void g() {

// other operations should not be locked...

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

+ ":not synchronized in g()");

synchronized (syncObject1) {

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

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

+ ":synchronized in g()");

try {

TimeUnit.SECONDS.sleep(3);

} catch (InterruptedException e) {

e.printStackTrace();

}

public void h() {

// other operations should not be locked...

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

+ ":not synchronized in h()");

synchronized (syncObject2) {

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

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

+ ":synchronized in h()");

try {

TimeUnit.SECONDS.sleep(3);

} catch (InterruptedException e) {

e.printStackTrace();

}

public static void main(String[] args) {

final Resource2 rs = new Resource2();

new Thread() {

public void run() {

rs.f();

}

}.start();

new Thread() {

public void run() {

rs.g();

}

}.start();

rs.h();

}

结果：

Thread-0:not synchronized in f()

Thread-0:synchronized in f()

main:not synchronized in h()

main:synchronized in h()

Thread-1:not synchronized in g()

Thread-1:synchronized in g()

Thread-0:synchronized in f()

main:synchronized in h()

Thread-1:synchronized in g()

Thread-0:synchronized in f()

main:synchronized in h()

Thread-1:synchronized in g()

Thread-0:synchronized in f()

main:synchronized in h()

Thread-1:synchronized in g()

Thread-0:synchronized in f()

main:synchronized in h()

Thread-1:synchronized in g()

3.Lock对象锁

除了使用synchronized外，还可以使用Lock对象来创建临界区。Resource3.java的演示效果同Resource1.java；Resource4.java的演示效果同Resource2.java。

Resource3.java

package com.zj.lock;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;

public class Resource3 {

private Lock lock = new ReentrantLock();

public void f() {

// other operations should not be locked...

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

+ ":not synchronized in f()");

lock.lock();

try {

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

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

+ ":synchronized in f()");

try {

TimeUnit.SECONDS.sleep(3);

} catch (InterruptedException e) {

e.printStackTrace();

}

} finally {

lock.unlock();

}

public void g() {

// other operations should not be locked...

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

+ ":not synchronized in g()");

lock.lock();

try {

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

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

+ ":synchronized in g()");

try {

TimeUnit.SECONDS.sleep(3);

} catch (InterruptedException e) {

e.printStackTrace();

}

} finally {

lock.unlock();

}

public void h() {

// other operations should not be locked...

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

+ ":not synchronized in h()");

lock.lock();

try {

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

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

+ ":synchronized in h()");

try {

TimeUnit.SECONDS.sleep(3);

} catch (InterruptedException e) {

e.printStackTrace();

}

} finally {

lock.unlock();

}

public static void main(String[] args) {

final Resource3 rs = new Resource3();

new Thread() {

public void run() {

rs.f();

}

}.start();

new Thread() {

public void run() {

rs.g();

}

}.start();

rs.h();

}

结果：

Thread-0:not synchronized in f()

Thread-0:synchronized in f()

main:not synchronized in h()

Thread-1:not synchronized in g()

Thread-0:synchronized in f()

main:synchronized in h()

Thread-1:synchronized in g()

Resource4.java

package com.zj.lock;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;

public class Resource4 {

private Lock lock1 = new ReentrantLock();

private Lock lock2 = new ReentrantLock();

private Lock lock3 = new ReentrantLock();

public void f() {

// other operations should not be locked...

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

+ ":not synchronized in f()");

lock1.lock();

try {

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

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

+ ":synchronized in f()");

try {

TimeUnit.SECONDS.sleep(3);

} catch (InterruptedException e) {

e.printStackTrace();

}

} finally {

lock1.unlock();

}

public void g() {

// other operations should not be locked...

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

+ ":not synchronized in g()");

lock2.lock();

try {

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

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

+ ":synchronized in g()");

try {

TimeUnit.SECONDS.sleep(3);

} catch (InterruptedException e) {

e.printStackTrace();

}

} finally {

lock2.unlock();

}

public void h() {

// other operations should not be locked...

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

+ ":not synchronized in h()");

lock3.lock();

try {

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

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

+ ":synchronized in h()");

try {

TimeUnit.SECONDS.sleep(3);

} catch (InterruptedException e) {

e.printStackTrace();

}

} finally {

lock3.unlock();

}

public static void main(String[] args) {

final Resource4 rs = new Resource4();

new Thread() {

public void run() {

rs.f();

}

}.start();

new Thread() {

public void run() {

rs.g();

}

}.start();

rs.h();

}

结果：

Thread-0:not synchronized in f()

Thread-0:synchronized in f()

main:not synchronized in h()

main:synchronized in h()

Thread-1:not synchronized in g()

Thread-1:synchronized in g()

Thread-0:synchronized in f()

main:synchronized in h()

Thread-1:synchronized in g()

Thread-0:synchronized in f()

main:synchronized in h()

Thread-1:synchronized in g()

Thread-0:synchronized in f()

main:synchronized in h()

Thread-1:synchronized in g()

Thread-0:synchronized in f()

main:synchronized in h()

Thread-1:synchronized in g()

Java:使用synchronized和Lock对象获取对象锁的更多相关文章

Java中synchronized和Lock的区别
synchronized和Lock的区别synchronize锁对象可以是任意对象,由于监视器方法必须要拥有锁对象那么任意对象都可以调用的方法所以将其抽取到Object类中去定义监视器方法这样锁对象和 ...
java中synchronized与Lock的异同
本文转载自java中synchronized与Lock的异同前言 synchronized和Lock通过互斥保障原子性,能够保护共享数据以实现线程安全,其作用包括保障原子性.可见性.有序性常见问题 ...
JAVA中synchronized和lock详解
目前在Java中存在两种锁机制:synchronized和Lock,Lock接口及其实现类是JDK5增加的内容,其作者是大名鼎鼎的并发专家Doug Lea.本文并不比较synchronize ...
【Java】synchronized与lock的区别
从Java 5之后,在java.util.concurrent.locks包下提供了另外一种方式来实现同步访问,那就是Lock. 也许有朋友会问,既然都可以通过synchronized来实现同步访问了 ...
java多线程:synchronized和lock比较浅析
转载:http://www.toutiao.com/a6392135944652587266/?tt_from=weixin&utm_campaign=client_share&app ...
java 多线程 synchronized与lock的通信机制等问题,结合相应实例说明
1. 利用多线程实现如下需求: 写两个线程,一个线程打印1~52,另一个线程打印A~Z,打印顺序是12A34B...5152Z: 2. 使用synchronized 实现 public class T ...
java多线程 synchronized 与lock锁实现线程安全
如果有多个线程在同时运行,而这些线程可能会同时运行这段代码.程序每次运行结果和单线程运行的结果是一样的,而且其他的变量的值也和预期的是一样的,就是线程安全的. 通过卖火车票的例子火车站要卖票,我们模 ...
Java中Synchronized和Lock的使用
Lock的锁定是通过代码实现的,而 synchronized 是在 JVM 层面上实现的 synchronized在锁定时如果方法块抛出异常,JVM 会自动将锁释放掉,不会因为出了异常没有释放锁造成线 ...
java面试-synchronized与lock有什么区别？
1.原始构成: synchronized是关键字,属于JVM层面,底层是由一对monitorenter和monitorexit指令实现的. ReentrantLock是一个具体类,是API层面的锁. ...

随机推荐

c#操作MySQL数据库中文出现乱码（很多问号）的解决方法
前题:修改discuz论坛帖子老连接(从NT版转到PHP版的discuzX3),帖子里有很多引用,有链接都是.aspx这样的链接. 需要将这些链接改到当前论坛的链接. 思路:用asp.net程序获取含 ...
python 冒泡和快排，不多说【无聊】
#-*-coding:utf8-*- import random a=[] b=[] def init_array(): for i in range(10000): v = random.randi ...
eclipse SVN 安装
1.下载最新的Eclipse,我的版本是3.7.2 indigo(Eclipse IDE for Java EE Developers)版如果没有安装的请到这里下载安装:http://ecli ...
Oracle 批量造数据
1.通过存储过程方式 CREATE OR REPLACE procedure XXZY.p_test is i number; begin .. loop INSERT INTO test_job V ...
MYSQL异常和错误机制
BEGIN ; ; ; START TRANSACTION; call put_playerbehavior(i_playerid,i_gameid,i_channelid,i_acttime,@a) ...
React使用笔记(3)-React Event Listener
Date: 2015-11-28 12:18 Category: Web Tags: JavaScript Author: 刘理想 [toc] 1. 构造基本结构首先,我们先创建一个按钮,一个输入框 ...
1_HelloWorld
学iOS开发与学Swift是两件事情,Swift只是一种语言,它有官方手册,里面包含了全部的语法.对其他任何一门语言很熟悉的人,学习Swift可能只需要几天的时间.而这之后,学习iOS开发才是难点,有 ...
Hello China操作系统STM32移植指南（二）
移植步骤详解下面就以MDK 4.72为开发环境,详细说明Hello China内核向STM32的移植过程.MDK 4.72评估版只支持32K代码的编译,这对Hello China的内核来说,裁剪掉一 ...
linux 多线程编程笔记
一, 线程基础知识 1,线程的概念线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计 ...
Objective-C浅拷贝和深拷贝
浅拷贝就是对内存地址的复制,让目标对象指针和源对象指向同一片内存空间如: char* str = (char*)malloc(100);char* str2 = str; 浅拷贝只是对对象的简单拷贝 ...

Java:使用synchronized和Lock对象获取对象锁

Java:使用synchronized和Lock对象获取对象锁的更多相关文章

随机推荐

热门专题