Lock是java.util.concurrent.locks包下的接口,Lock 实现提供了比使用synchronized 方法和语句可获得的更广泛的锁定操作,它能以更优雅的方式处理线程同步问题,我们拿Java线程(二)中的一个例子简单的实现一下和sychronized一样的效果,代码如下:
- public class LockTest {
- public static void main(String[] args) {
- final Outputter1 output = new Outputter1();
- new Thread() {
- public void run() {
- output.output("zhangsan");
- };
- }.start();
- new Thread() {
- public void run() {
- output.output("lisi");
- };
- }.start();
- }
- }
- class Outputter1 {
- private Lock lock = new ReentrantLock();// 锁对象
- public void output(String name) {
- // TODO 线程输出方法
- lock.lock();// 得到锁
- try {
- for(int i = 0; i < name.length(); i++) {
- System.out.print(name.charAt(i));
- }
- } finally {
- lock.unlock();// 释放锁
- }
- }
- }
这样就实现了和sychronized一样的同步效果,需要注意的是,用sychronized修饰的方法或者语句块在代码执行完之后锁自动释放,而用 Lock需要我们手动释放锁,所以为了保证锁最终被释放(发生异常情况),要把互斥区放在try内,释放锁放在finally内。
如果说这就是Lock,那么它不能成为同步问题更完美的处理方式,下面要介绍的是读写锁(ReadWriteLock),我们会有一种需求,在对数据进行 读写的时候,为了保证数据的一致性和完整性,需要读和写是互斥的,写和写是互斥的,但是读和读是不需要互斥的,这样读和读不互斥性能更高些,来看一下不考 虑互斥情况的代码原型:
- public class ReadWriteLockTest {
- public static void main(String[] args) {
- final Data data = new Data();
- for (int i = 0; i < 3; i++) {
- new Thread(new Runnable() {
- public void run() {
- for (int j = 0; j < 5; j++) {
- data.set(new Random().nextInt(30));
- }
- }
- }).start();
- }
- for (int i = 0; i < 3; i++) {
- new Thread(new Runnable() {
- public void run() {
- for (int j = 0; j < 5; j++) {
- data.get();
- }
- }
- }).start();
- }
- }
- }
- class Data {
- private int data;// 共享数据
- public void set(int data) {
- System.out.println(Thread.currentThread().getName() + "准备写入数据");
- try {
- Thread.sleep(20);
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- this.data = data;
- System.out.println(Thread.currentThread().getName() + "写入" + this.data);
- }
- public void get() {
- System.out.println(Thread.currentThread().getName() + "准备读取数据");
- try {
- Thread.sleep(20);
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- System.out.println(Thread.currentThread().getName() + "读取" + this.data);
- }
- }
部分输出结果:
- Thread-1准备写入数据
- Thread-3准备读取数据
- Thread-2准备写入数据
- Thread-0准备写入数据
- Thread-4准备读取数据
- Thread-5准备读取数据
- Thread-2写入12
- Thread-4读取12
- Thread-5读取5
- Thread-1写入12
我们要实现写入和写入互斥,读取和写入互斥,读取和读取互斥,在set和get方法加入sychronized修饰符:
- public synchronized void set(int data) {...}
- public synchronized void get() {...}
部分输出结果:
- Thread-0准备写入数据
- Thread-0写入9
- Thread-5准备读取数据
- Thread-5读取9
- Thread-5准备读取数据
- Thread-5读取9
- Thread-5准备读取数据
- Thread-5读取9
- Thread-5准备读取数据
- Thread-5读取9
我们发现,虽然写入和写入互斥了,读取和写入也互斥了,但是读取和读取之间也互斥了,不能并发执行,效率较低,用读写锁实现代码如下:
- class Data {
- private int data;// 共享数据
- private ReadWriteLock rwl = new ReentrantReadWriteLock();
- public void set(int data) {
- rwl.writeLock().lock();// 取到写锁
- try {
- System.out.println(Thread.currentThread().getName() + "准备写入数据");
- try {
- Thread.sleep(20);
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- this.data = data;
- System.out.println(Thread.currentThread().getName() + "写入" + this.data);
- } finally {
- rwl.writeLock().unlock();// 释放写锁
- }
- }
- public void get() {
- rwl.readLock().lock();// 取到读锁
- try {
- System.out.println(Thread.currentThread().getName() + "准备读取数据");
- try {
- Thread.sleep(20);
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- System.out.println(Thread.currentThread().getName() + "读取" + this.data);
- } finally {
- rwl.readLock().unlock();// 释放读锁
- }
- }
- }
部分输出结果:
- Thread-4准备读取数据
- Thread-3准备读取数据
- Thread-5准备读取数据
- Thread-5读取18
- Thread-4读取18
- Thread-3读取18
- Thread-2准备写入数据
- Thread-2写入6
- Thread-2准备写入数据
- Thread-2写入10
- Thread-1准备写入数据
- Thread-1写入22
- Thread-5准备读取数据
从结果可以看出实现了我们的需求,这只是锁的基本用法,锁的机制还需要继续深入学习。
本文来自:高爽|Coder,原文地址:http://blog.csdn.net/ghsau/article/details/7461369,转载请注明。
在java中有两种方式实现原子性操作(即同步操作):
1)使用同步关键字synchronized
2)使用lock锁机制其中也包括相应的读写锁
package com.xiaohao.test;
import java.util.Random;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class Test {
public static void main(String[] args) {
final LockTest lock=new LockTest();
//输出张三
new Thread(){
public void run(){
lock.test("张三张三张三张三张三张三张三张三张三张三");
}
}.start();
//输出李四
new Thread(){
public void run(){
lock.test("李四李四李四李四李四李四李四李四李四李四");System.out.println
("\n---------------------------------------------------------------");
}
}.start();
//---------------------------------------------------------------
//模拟写入数据的
for (int i = 0; i < 3; i++) {
new Thread(){
public void run() {
for (int j = 0; j < 5; j++) {
// lock.set(new Random().nextInt(30));
lock.set2(new Random().nextInt(30));
}
}
}.start();
}
//模拟读取数据的
for (int i = 0; i < 3; i++) {
new Thread(){
public void run() {
for (int j = 0; j < 5; j++) {
// lock.get();
lock.get2();
}
}
}.start();
}
}
}
class LockTest{
private Lock lock=new ReentrantLock(); //创建普通的锁
private ReadWriteLock readWriteLock=new ReentrantReadWriteLock();//创建读写锁
private int data;// 共享数据
//实现同步的方法一 使用同步关键字 synchronized
public synchronized void test(String name){
//下面的相关操作是一个原子性的操作
// lock.lock();// 得到锁
try {
for(int i = 0; i < name.length(); i++) {
System.out.print(name.charAt(i));
}
} finally {
// lock.unlock();// 释放锁
}
}
//实现同步的方法二 使用lock锁机制
public void test2(String name){
//下面的相关操作是一个原子性的操作
lock.lock();// 得到锁
try {
for(int i = 0; i < name.length(); i++) {
System.out.print(name.charAt(i));
}
} finally {
lock.unlock();// 释放锁
}
}
//使用set方法模拟写入数据
//使用 synchronized 实现了读读,写写,读写之间的互斥 ,但读读之间的互斥是没有什么必要的
public synchronized void set(int data){
System.out.println(Thread.currentThread().getName() + "准备写入数据");
try {
Thread.sleep(20);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.data = data;
System.out.println(Thread.currentThread().getName() + "写入" + this.data);
}
//使用get方法模拟读取数据
//使用 synchronized 实现了读读,写写,读写之间的互斥 ,但读读之间的互斥是没有什么必要的
public synchronized void get() {
System.out.println(Thread.currentThread().getName() + "准备读取数据");
try {
Thread.sleep(20);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "读取" + this.data);
}
//使用set方法模拟写入数据
//使用 读写锁实现了写写,读写之间的互斥 ,但读读之间的互斥是没有什么必要的
public void set2(int data){
readWriteLock.writeLock().lock();//获取写入锁
try{
System.out.println(Thread.currentThread().getName() + "准备写入数据");
try {
Thread.sleep(20);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.data = data;
System.out.println(Thread.currentThread().getName() + "写入" + this.data);
}
finally{
readWriteLock.writeLock().unlock();
}
}
//使用get方法模拟读取数据
//使用 读写锁实现了写写,读写之间的互斥 ,但读读之间的互斥是没有什么必要的
public void get2() {
//获取相应的读锁
readWriteLock.readLock().lock();
try{
System.out.println(Thread.currentThread().getName() + "准备读取数据");
try {
Thread.sleep(20);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "读取" + this.data);
}
finally{
// 释放相应的写锁
readWriteLock.readLock().unlock();
}
}
}
线程同步经典版:
package com.xiaohao.test;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class Test2{
public static void main(String[] args){
final LockTest2 lockTest=new LockTest2();
for(int i=0;i<3;i++) {
new Thread(){
public void run(){
try {
for (int j = 0; j < 3; j++) {
lockTest.setValue();
} } catch (InterruptedException e) {
// TODO Auto-generated catch block e.printStackTrace();
}
}
}.start();
}
for(int i=0;i<3;i++) {
new Thread(){
public void run(){
try {
for (int j = 0; j < 3; j++) {
lockTest.getValue();
}
} catch (InterruptedException e)
{ // TODO Auto-generated catch block e.printStackTrace(); }
}
}.start();
}
}
}
class LockTest2 {
int data=0;
ReentrantReadWriteLock lock= new ReentrantReadWriteLock();// 锁对象
public void setValue() throws InterruptedException{
lock.writeLock().lock();
System.out.println("正在使用写锁......");
data=(int) (Math.random()*10);
System.out.println("正在写入:"+data);
Thread.sleep(500);
System.out.println("写锁调用完毕---------------------------");
lock.writeLock().unlock(); }
public void getValue() throws InterruptedException{
lock.readLock().lock();
System.out.println("正在使用读锁...........................................");
System.out.println("正在读入:"+data); Thread.sleep(500);
System.out.println("读锁调用完毕......");
lock.readLock().unlock();
}
}
**** 当一个线程进入了一个对象是的synchronized方法,那么其它线程还能掉否调用此对象的其它方法?
这个问题需要分几种情况进行讨论。
1)查看其它方法是否使用了同步关键字(synchronized)修饰,如果没有的话就可以调用相关的方法。
2)在当前synchronized方法中是否调用了wait方法,如果调用了,则对应的锁已经释放,可以访问了。
3)如果其它方法也使用synchronized修饰,并且当前同步方法中没有调用wait方法的话,这样是不允许访问的。
4)如果其它方法是静态方法的话,由于静态方法和对象是扯不上什么关系,对于静态同步方法而言,其对应的同步监视器为当前类的字节码
所以肯定可以访问的了。
相关推荐
在jdk1.5以后,JAVA提供了Lock类来实现和synchronized一样的功能,并且还提供了Condition来显示线程间通信。 Lock类是Java类来提供的功能,丰富的api使得Lock类的同步功能比synchronized的同步更强大。本文章的所有...
当你在linux中安装eclipse或者安装其他的包时遇到这样得问题:java: xcb_xlib.c:50: xcb_xlib_unlock: Assertion `c->xlib.lock' failed,可以按照下面步骤:第一:倒退回FC7的libx11. 卸载以下两个包的时候,可能有...
在Java语言中,有两个特殊的类用于多线程同步,分别是synchronized关键字和ReentrantLock类。 1. synchronized关键字 synchronized关键字是Java语言中的一种同步机制,用于对方法或者代码块进行同步。synchronized...
主要介绍了MySQL启动报错问题InnoDB:Unable to lock/ibdata1 error,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
1. Java中的异常类型:Java中有两种异常类型:checked异常和unchecked异常。checked异常是编译器强制要求捕获的异常,而unchecked异常是运行时异常。 2. Java中的try-catch块:try-catch块是Java中的异常处理机制。...
Java领域中有两种锁的实现方式,一种是基于Java语法层面的锁,另一种是基于JDK层面的锁。基于JDK层面的锁主要可以分为四种方式,其中AbstractQueuedSynchronizer(AQS)是Java SDK并发包中主要的同步器实现。 AQS是...
13丨多线程之锁优化(中):深入了解Lock同步锁的优化方法.html
对于引用类型和非线程安全的资源的同步处理,有四种相关处理:lock关键字,监视器(Monitor), 同步事件和等待句柄, mutex类。 Lock关键字 本人愚钝,在以前编程中遇到lock的问题总是使用lock(this)一锁了之,出...
解决SQLSTATE[HY000]: General error: 1205 Lock wait timeout exceeded
Lock、Synchronized 和 ReentrantLock 是 Java 中三种常用的同步机制,每种机制都有其特点和使用场景。下面对这三种机制进行详细的分析和比较。 一、Synchronized Synchronized 是 Java 中最基本的同步机制,它...
本文总结了Java中Lock的各种用法。
在 Java 中,锁机制是数据同步的关键,存在两种锁机制:synchronized 和 Lock。了解这两种锁机制的实现原理对于理解 Java 并发编程非常重要。 synchronized 锁机制是在软件层面实现的,它依赖 JVM 实现。 HotSpot ...
Lock锁是对象锁,仅在同一对象中,锁才会生效。(不做论证) (以下场景皆为单例模式下运行) lock.lock()的加锁方式,会使后续请求的线程堵塞等待。(方案A) lock.tryLock()的加锁方式,不会堵塞,会立即返回加锁...
Java 线程同步机制中 synchronized 关键字的理解 Java 的线程同步机制是为了解决多个线程共享同一片存储空间所带来的访问冲突问题。其中,synchronized 关键字是 Java 语言中解决这种冲突的重要机制。 ...
线程同步Synchronized,监视器monitor和锁lock的关系2---马克-to-win java视频
Baby Time: Android Wear Lock An app to prevent rugrats from accidentally SMSing China or ordering you a Lyft car when you’re holding them. It keeps the screen on, but at its lowest brightness setting...
1.4.1 类(Class):Java世界中一类物体 14 1.4.2 方法(Method):物体的功能 15 1.4.3 main()方法:所有Java程序执行的起点 15 .1.5 名词解释 16 1.5.1 JDK和Java平台 16 1.5.2 Java编译器(Java Compiler)...
基础理论知识,描述lock和synchronized的区别和基础的理论,其中还有死锁等基础概念。
线程同步 为了使不同线程在使用统一共享内存时线程之间互不影响,需要使用 “Lock()”方法。 具体实现: import threading def job1(): global A, lock lock.acquire() #内存上锁 for i in range(10): A += 1 print...
其中,继承Thread类和实现Runnable接口是最常用的两种方式。 线程的生命周期包括五种基本状态:新建状态、就绪状态、运行状态、阻塞状态和死亡状态。在Java中,线程的调度算法是时间片轮转算法,线程调度器会根据...